gs-predicate/src/test/scala/gs/predicate/v0/json/JsonComparisonTests.scala

package gs.predicate.v0.json

import gs.datagen.v0.Gen
import gs.datagen.v0.generators.Range
import io.circe.Json
import java.time.LocalDate
import munit.FunSuite

class JsonComparisonTests extends FunSuite:
  import JsonComparisonTests.*

  test("should support True") {
    val jc = JsonComparison.True
    assert(jc.compare(Json.obj()))
  }

  test("should support False") {
    val jc = JsonComparison.False
    assert(!jc.compare(Json.obj()))
  }

  test("should support And") {
    val jc1 = JsonComparison.And(
      List(JsonComparison.True, JsonComparison.True, JsonComparison.False)
    )
    val jc2 = JsonComparison.And(List(JsonComparison.True, JsonComparison.True))
    val jc3 = JsonComparison.And(List())
    val json = Json.obj()
    assert(!jc1.compare(json))
    assert(jc2.compare(json))
    assert(jc3.compare(json))
  }

  test("should support Or") {
    val jc1 = JsonComparison.Or(
      List(JsonComparison.True, JsonComparison.True, JsonComparison.False)
    )
    val jc2 =
      JsonComparison.Or(List(JsonComparison.False, JsonComparison.False))
    val jc3  = JsonComparison.Or(List())
    val json = Json.obj()
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support Eq") {
    val key   = keyGen.gen()
    val value = jsonStringGen.gen()
    val json  = Json.obj(key -> value)
    val other = Json.obj("x" -> value)
    val jc    = JsonComparison.Eq(json)
    assert(jc.compare(json))
    assert(!jc.compare(other))
  }

  test("should support Neq") {
    val key   = keyGen.gen()
    val value = jsonStringGen.gen()
    val json  = Json.obj(key -> value)
    val other = Json.obj("x" -> value)
    val jc    = JsonComparison.Neq(json)
    assert(!jc.compare(json))
    assert(jc.compare(other))
  }

  test("should support StringContains") {
    val str    = strGen.gen()
    val substr = str.substring(3, 7)
    val json   = Json.fromString(str)
    val jc1    = JsonComparison.StringContains(substr)
    val jc2    = JsonComparison.StringContains(str)
    val jc3    = JsonComparison.StringContains(longStrGen.gen())
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support StringPrefix") {
    val str    = strGen.gen()
    val substr = str.take(4)
    val json   = Json.fromString(str)
    val jc1    = JsonComparison.StringPrefix(substr)
    val jc2    = JsonComparison.StringPrefix(str)
    val jc3    = JsonComparison.StringPrefix(longStrGen.gen())
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support StringSuffix") {
    val str    = strGen.gen()
    val substr = str.takeRight(4)
    val json   = Json.fromString(str)
    val jc1    = JsonComparison.StringSuffix(substr)
    val jc2    = JsonComparison.StringSuffix(str)
    val jc3    = JsonComparison.StringSuffix(longStrGen.gen())
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntLessThan") {
    val int    = intGen.gen()
    val target = 101
    val json   = Json.fromInt(int)
    val jc1    = JsonComparison.IntLessThan(target)
    val jc3    = JsonComparison.IntLessThan(-1)
    assert(jc1.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntLessThanOrEqualTo") {
    val int    = intGen.gen()
    val target = 101
    val json   = Json.fromInt(int)
    val jc1    = JsonComparison.IntLessThanOrEqualTo(target)
    val jc2    = JsonComparison.IntLessThanOrEqualTo(int)
    val jc3    = JsonComparison.IntLessThan(-1)
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntGreaterThan") {
    val int    = intGen.gen()
    val target = -1
    val json   = Json.fromInt(int)
    val jc1    = JsonComparison.IntGreaterThan(target)
    val jc3    = JsonComparison.IntGreaterThan(101)
    assert(jc1.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntGreaterThanOrEqualTo") {
    val int    = intGen.gen()
    val target = -1
    val json   = Json.fromInt(int)
    val jc1    = JsonComparison.IntGreaterThanOrEqualTo(target)
    val jc2    = JsonComparison.IntGreaterThanOrEqualTo(int)
    val jc3    = JsonComparison.IntGreaterThan(101)
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntBetweenInclusive") {
    val int   = intGen.gen()
    val lower = 0
    val upper = 100
    val json  = Json.fromInt(int)
    val jc1   = JsonComparison.IntBetweenInclusive(lower, upper)
    val jc2   = JsonComparison.IntBetweenInclusive(int, int)
    val jc3   = JsonComparison.IntBetweenInclusive(1000, 10000)
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support IntBetweenExclusive") {
    val int   = intGen.gen()
    val lower = -1
    val upper = 101
    val json  = Json.fromInt(int)
    val jc1   = JsonComparison.IntBetweenExclusive(lower, upper)
    val jc2   = JsonComparison.IntBetweenExclusive(int, int)
    val jc3   = JsonComparison.IntBetweenExclusive(1000, 10000)
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support DateEq") {
    val date   = dateGen.gen()
    val target = date
    val json   = Json.fromString(date.toString())
    val jc1    = JsonComparison.DateEq(target)
    val jc2    = JsonComparison.DateEq(target.plusDays(1L))
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
  }

  test("should support DateBefore") {
    val date   = dateGen.gen()
    val target = date.plusDays(1L)
    val json   = Json.fromString(date.toString())
    val jc1    = JsonComparison.DateBefore(target)
    val jc2    = JsonComparison.DateBefore(date)
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
  }

  test("should support DateAfter") {
    val date   = dateGen.gen()
    val target = date.minusDays(1L)
    val json   = Json.fromString(date.toString())
    val jc1    = JsonComparison.DateAfter(target)
    val jc2    = JsonComparison.DateAfter(date)
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
  }

  test("should support DateBetweenInclusive") {
    val date  = dateGen.gen()
    val lower = date.minusDays(1L)
    val upper = date.plusDays(1L)
    val json  = Json.fromString(date.toString())
    val jc1   = JsonComparison.DateBetweenInclusive(lower, upper)
    val jc2   = JsonComparison.DateBetweenInclusive(date, date)
    val jc3   = JsonComparison.DateBetweenInclusive(
      date.plusDays(1L),
      date.plusDays(1000L)
    )
    assert(jc1.compare(json))
    assert(jc2.compare(json))
    assert(!jc3.compare(json))
  }

  test("should support DateBetweenExclusive") {
    val date  = dateGen.gen()
    val lower = date.minusDays(1L)
    val upper = date.plusDays(1L)
    val json  = Json.fromString(date.toString())
    val jc1   = JsonComparison.DateBetweenExclusive(lower, upper)
    val jc2   = JsonComparison.DateBetweenExclusive(date, date)
    val jc3   = JsonComparison.DateBetweenExclusive(
      date.plusDays(1L),
      date.plusDays(1000L)
    )
    assert(jc1.compare(json))
    assert(!jc2.compare(json))
    assert(!jc3.compare(json))
  }

object JsonComparisonTests:

  val keyGen: Gen[String]      = Gen.string.alphaNumeric(Range.between(8, 16))
  val strGen: Gen[String]      = Gen.string.alphaNumeric(Range.between(8, 16))
  val longStrGen: Gen[String]  = Gen.string.alphaNumeric(Range.fixed(32))
  val jsonStringGen: Gen[Json] = strGen.map(Json.fromString)
  val intGen: Gen[Int]         = Gen.integer.inRange(0, 100)
  val dateGen: Gen[LocalDate]  = Gen.date.aroundToday(Range.between(1, 3))

end JsonComparisonTests