## Ruby validator -- exhaustive edge-case tests.
## Auto-generated. Tests valid code, invalid code, encoding attacks,
## nesting extremes, unicode bombs, binary injection, and more.

import std/[unittest, strutils, strformat, json]
import ../src/nimcheck

proc checkValid(result: ValidationResult, context: string = "") =
  if result.errors.len > 0:
    var msg = &"Expected valid, got {result.errors.len} error(s)"
    if context.len > 0: msg.add(&" [{context}]")
    for e in result.errors: msg.add(&"\n  [{e.code}] {e.message}")
    doAssert false, msg

proc checkInvalid(result: ValidationResult, context: string = "") =
  if result.errors.len == 0:
    doAssert false, &"Expected errors, got none [{context}]"

proc checkHasError(result: ValidationResult, code: string, context: string = "") =
  var found = false
  for e in result.errors:
    if e.code == code: found = true
  if not found:
    var codes: seq[string] = @[]
    for e in result.errors: codes.add(e.code)
    let codesJoined = codes.join(", ")
    doAssert false, "Expected error code '" & code & "', got " & codesJoined & " [" & context & "]"

proc checkSeverity(result: ValidationResult, sev: string, context: string = "") =
  var found = false
  for e in result.errors:
    if $e.severity == sev: found = true
  if not found:
    doAssert false, &"Expected severity '{sev}', none found [{context}]"

suite "Ruby Exhaustive Tests":

  test "basic valid method":
    let src = "def hello(name)\n  \"Hello, #{name}!\"\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "unclosed string":
    let src = "def broken\n  x = \"unclosed\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "symbol and hash syntax":
    let src = "h = { foo: 1, 'bar' => 2 }\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "block with do/end":
    let src = "[1, 2, 3].each do |n|\n  puts n\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "class with inheritance":
    let src = "class Animal\n  def speak\n    \"...\"\n  end\nend\nclass Dog < Animal\n  def speak\n    \"Woof!\"\n  end\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "module mixin":
    let src = "module Greetable\n  def greet\n    \"Hello!\"\n  end\nend\nclass Person\n  include Greetable\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "lambda and proc":
    let src = "add = ->(a, b) { a + b }\nmul = Proc.new { |a, b| a * b }\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "rescue/ensure":
    let src = "def safe_div(a, b)\n  a / b\nrescue ZeroDivisionError\n  0\nensure\n  puts \"done\"\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "heredoc string":
    let src = "s = <<~EOF\n  hello world\nEOF\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "empty source":
    let src = ""
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "null byte injection":
    let src = "x = 1\x00y = 2\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "symbol interpolation":
    let src = "name = \"world\"\ns = :\"Hello, #{name}\"\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "unicode identifiers":
    let src = "def méthode\n  :ok\nend\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0

  test "only comments":
    let src = "# just a comment\n  \n=begin\nmulti line\n=end\n"
    let result = validateSource(src, flavor = lfRuby)
    check result.errors.len >= 0