add json format tests for Slot and Eligibility arms

5 files changed, 117 insertions, 86 deletions

diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
index 48fc99b..609c8c8 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/PaginationParserSuite.scala
@@ -11,36 +11,40 @@ class PaginationParserSuite extends FreeSpecLike with MustMatchers {
   "parse" - {
     "pageSize" - {
       "should parse positive value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "10",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "10",
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 10
       }
 
       "should return a default value if there is no one" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 100
       }
 
       "should return a error for zero value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "0",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "0",
+            "pageNumber" -> "1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageSize")
       }
 
       "should return a error for negative value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "-10",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "-10",
+            "pageNumber" -> "1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageSize")
       }
@@ -48,36 +52,40 @@ class PaginationParserSuite extends FreeSpecLike with MustMatchers {
 
     "pageNumber" - {
       "should parse positive value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "1"
+          ))
         pagination must success
         pagination.get.pageSize mustBe 1
       }
 
       "should return a default value if there is no one" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize" -> "1"
+          ))
         pagination must success
         pagination.get.pageNumber mustBe 1
       }
 
       "should return a error for zero value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "0"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "0"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageNumber")
       }
 
       "should return a error for negative value" in {
-        val pagination = PaginationParser.parse(Seq(
-          "pageSize" -> "1",
-          "pageNumber" -> "-1"
-        ))
+        val pagination = PaginationParser.parse(
+          Seq(
+            "pageSize"   -> "1",
+            "pageNumber" -> "-1"
+          ))
 
         checkFailedValidationOnlyOn(pagination, "pageNumber")
       }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
index 5deaecb..02243aa 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
@@ -30,16 +30,20 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     "should convert column names to snake case" in {
       import SearchFilterBinaryOperation._
 
-      val filter = SearchFilterParser.parse(Seq(
-        "filters" -> "status IN Summarized,ReviewCriteria,Flagged,Done",
-        "filters" -> "previousStatus NOTEQ New",
-        "filters" -> "previousStatus NOTEQ ReviewSummary"
-      ))
-
-      assert(filter === Success(SearchFilterExpr.Intersection(List(
-        SearchFilterExpr.Atom.NAry(Dimension(None, "status"), In, Seq("Summarized", "ReviewCriteria", "Flagged", "Done")),
-        SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "New"),
-        SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "ReviewSummary")))))
+      val filter = SearchFilterParser.parse(
+        Seq(
+          "filters" -> "status IN Summarized,ReviewCriteria,Flagged,Done",
+          "filters" -> "previousStatus NOTEQ New",
+          "filters" -> "previousStatus NOTEQ ReviewSummary"
+        ))
+
+      assert(
+        filter === Success(SearchFilterExpr.Intersection(List(
+          SearchFilterExpr.Atom
+            .NAry(Dimension(None, "status"), In, Seq("Summarized", "ReviewCriteria", "Flagged", "Done")),
+          SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "New"),
+          SearchFilterExpr.Atom.Binary(Dimension(None, "previous_status"), NotEq, "ReviewSummary")
+        ))))
     }
     "dimensions" - {
       "with table name" in check {
@@ -50,11 +54,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
         Prop.forAllNoShrink(dimensionGen) {
           case (left, right) =>
             val raw = s"$left.$right"
-            val l = toSnakeCase(left)
-            val r = toSnakeCase(right)
-              SearchFilterParser.dimensionParser.parse(raw) match {
+            val l   = toSnakeCase(left)
+            val r   = toSnakeCase(right)
+            SearchFilterParser.dimensionParser.parse(raw) match {
               case Parsed.Success(Dimension(Some(`l`), `r`), _) => true
-              case _ => false
+              case _                                            => false
             }
         }
       }
@@ -63,7 +67,7 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
           val databaseS = Utils.toSnakeCase(s)
           SearchFilterParser.dimensionParser.parse(s) match {
             case Parsed.Success(Dimension(None, `databaseS`), _) => true
-            case _ => false
+            case _                                               => false
           }
         }
       }
@@ -81,10 +85,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
-              SearchFilterParser.parse(Seq("filters" -> query))
+              SearchFilterParser
+                .parse(Seq("filters" -> query))
                 .map {
                   case SearchFilterExpr.Atom.Binary(_, Eq | NotEq | Like, _) => true
-                  case x => throw new UnexpectedSearchFilterExprException(x)
+                  case x                                                     => throw new UnexpectedSearchFilterExprException(x)
                 }
                 .successProp
             }
@@ -96,7 +101,9 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             val testQueryGen = queryGen(
               dimensionGen = Gen.identifier,
               opGen = numericBinaryOpsGen,
-              valueGen = nonEmptyString.filter { s => !s.matches("^\\d+$") }
+              valueGen = nonEmptyString.filter { s =>
+                !s.matches("^\\d+$")
+              }
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
@@ -121,10 +128,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
             )
 
             Prop.forAllNoShrink(testQueryGen) { query =>
-              SearchFilterParser.parse(Seq("filters" -> query))
+              SearchFilterParser
+                .parse(Seq("filters" -> query))
                 .map {
                   case _: SearchFilterExpr.Atom.Binary => true
-                  case x => throw new UnexpectedSearchFilterExprException(x)
+                  case x                               => throw new UnexpectedSearchFilterExprException(x)
                 }
                 .successProp
             }
@@ -140,7 +148,8 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
               case Success(_) => ()
               case Failure(t) => t.printStackTrace()
             }
-            assert(filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5)))))
+            assert(
+              filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5)))))
           }
         }
 
@@ -152,10 +161,11 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
           )
 
           Prop.forAllNoShrink(testQueryGen) { query =>
-            SearchFilterParser.parse(Seq("filters" -> query))
+            SearchFilterParser
+              .parse(Seq("filters" -> query))
               .map {
                 case SearchFilterExpr.Atom.NAry(_, SearchFilterNAryOperation.In, _) => true
-                case x => throw new UnexpectedSearchFilterExprException(x)
+                case x                                                              => throw new UnexpectedSearchFilterExprException(x)
               }
               .successProp
           }
@@ -189,16 +199,19 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     }
   }
 
-  private val CommonBinaryOps = Seq("eq", "noteq", "like")
+  private val CommonBinaryOps  = Seq("eq", "noteq", "like")
   private val NumericBinaryOps = Seq("gt", "gteq", "lt", "lteq")
 
-  private val allBinaryOpsGen: Gen[String] = Gen.oneOf(CommonBinaryOps ++ NumericBinaryOps).flatMap(randomCapitalization)
-  private val commonBinaryOpsGen: Gen[String] = Gen.oneOf(CommonBinaryOps).flatMap(randomCapitalization)
+  private val allBinaryOpsGen: Gen[String] =
+    Gen.oneOf(CommonBinaryOps ++ NumericBinaryOps).flatMap(randomCapitalization)
+  private val commonBinaryOpsGen: Gen[String]  = Gen.oneOf(CommonBinaryOps).flatMap(randomCapitalization)
   private val numericBinaryOpsGen: Gen[String] = Gen.oneOf(NumericBinaryOps).flatMap(randomCapitalization)
 
   private val inValueCharsGen: Gen[Char] = arbitrary[Char].filter(_ != ',')
 
-  private val nonEmptyString = arbitrary[String].filter { s => !s.safeTrim.isEmpty }
+  private val nonEmptyString = arbitrary[String].filter { s =>
+    !s.safeTrim.isEmpty
+  }
 
   private val numericBinaryAtomValuesGen: Gen[String] = arbitrary[Long].map(_.toString)
   private val inValueGen: Gen[String] = {
@@ -208,18 +221,22 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
     Gen.containerOfN[Seq, String](size, inValueGen).map(_.mkString(","))
   }
 
-  private def queryGen(dimensionGen: Gen[String], opGen: Gen[String], valueGen: Gen[String]): Gen[String] = for {
-    dimension <- dimensionGen
-    op <- opGen
-    value <- valueGen
-  } yield s"$dimension $op $value"
+  private def queryGen(dimensionGen: Gen[String], opGen: Gen[String], valueGen: Gen[String]): Gen[String] =
+    for {
+      dimension <- dimensionGen
+      op        <- opGen
+      value     <- valueGen
+    } yield s"$dimension $op $value"
 
   private def randomCapitalization(input: String): Gen[String] = {
     Gen.containerOfN[Seq, Boolean](input.length, arbitrary[Boolean]).map { capitalize =>
-      input.view.zip(capitalize).map {
-        case (currChar, true) => currChar.toUpper
-        case (currChar, false) => currChar
-      }.mkString
+      input.view
+        .zip(capitalize)
+        .map {
+          case (currChar, true)  => currChar.toUpper
+          case (currChar, false) => currChar
+        }
+        .mkString
     }
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
index e46015c..f34f8e1 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
@@ -12,7 +12,7 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "single dimension" - commonTests(singleSortingQueryGen)
     "multiple dimensions in one query" - commonTests(multipleSortingQueryGen)
     "multiple queries" in {
-      val r = SortingParser.parse(Set("foo", "bar"), Seq("sort" -> "foo", "sort" ->"bar"))
+      val r = SortingParser.parse(Set("foo", "bar"), Seq("sort" -> "foo", "sort" -> "bar"))
       r must failWith[ParseQueryArgException]
     }
   }
@@ -21,7 +21,7 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "valid" in check {
       val inputGen: Gen[(Set[String], String)] = for {
         validDimensions <- dimensionsGen
-        sorting <- queryGen(validDimensions)
+        sorting         <- queryGen(validDimensions)
       } yield (validDimensions, sorting)
 
       Prop.forAllNoShrink(inputGen) {
@@ -33,7 +33,9 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
     "invalid" in check {
       val inputGen: Gen[(Set[String], String)] = for {
         validDimensions <- dimensionsGen
-        invalidDimensions <- dimensionsGen.filter { xs => xs.intersect(validDimensions).isEmpty }
+        invalidDimensions <- dimensionsGen.filter { xs =>
+                              xs.intersect(validDimensions).isEmpty
+                            }
         sorting <- queryGen(invalidDimensions)
       } yield (validDimensions, sorting)
 
@@ -46,12 +48,12 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
 
   private val dimensionsGen: Gen[Set[String]] = for {
     unPrefixedSize <- Gen.choose(0, 3)
-    prefixedSize <- Gen.choose(0, 3)
+    prefixedSize   <- Gen.choose(0, 3)
     if (unPrefixedSize + prefixedSize) > 0
 
     unPrefixedDimensions <- Gen.containerOfN[Set, String](unPrefixedSize, Gen.identifier)
 
-    prefixes <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
+    prefixes   <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
     dimensions <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
   } yield {
     val prefixedDimensions = prefixes.zip(dimensions).map {
@@ -62,30 +64,33 @@ class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
 
   private def multipleSortingQueryGen(validDimensions: Set[String]): Gen[String] = {
     val validDimensionsSeq = validDimensions.toSeq
-    val indexGen = Gen.oneOf(validDimensionsSeq.indices)
+    val indexGen           = Gen.oneOf(validDimensionsSeq.indices)
     val multipleDimensionsGen = Gen.nonEmptyContainerOf[Set, Int](indexGen).filter(_.size >= 2).map { indices =>
       indices.map(validDimensionsSeq.apply)
     }
 
     for {
-      dimensions <- multipleDimensionsGen
+      dimensions  <- multipleDimensionsGen
       isAscending <- Gen.containerOfN[Seq, Boolean](dimensions.size, arbitrary[Boolean])
     } yield {
-      isAscending.zip(dimensions)
+      isAscending
+        .zip(dimensions)
         .map {
-          case (true, dimension) => dimension
+          case (true, dimension)  => dimension
           case (false, dimension) => "-" + dimension
         }
         .mkString(",")
     }
   }
 
-  private def singleSortingQueryGen(validDimensions: Set[String]): Gen[String] = for {
-    isAscending <- arbitrary[Boolean]
-    dimensions <- Gen.oneOf(validDimensions.toSeq)
-  } yield isAscending match {
-    case true => dimensions
-    case false => "-" + dimensions
-  }
+  private def singleSortingQueryGen(validDimensions: Set[String]): Gen[String] =
+    for {
+      isAscending <- arbitrary[Boolean]
+      dimensions  <- Gen.oneOf(validDimensions.toSeq)
+    } yield
+      isAscending match {
+        case true  => dimensions
+        case false => "-" + dimensions
+      }
 
 }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
index 4892b95..09b60ed 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
@@ -22,8 +22,9 @@ object TestUtils {
         left.isFailure && left.failed.get.getClass == ct.runtimeClass,
         left match {
           case Success(x) => s"$left did not fail"
-          case Failure(e) => s"$left did fail with ${Utils.getClassSimpleName(e.getClass)}, " +
-            s"not ${Utils.getClassSimpleName(ct.runtimeClass)}"
+          case Failure(e) =>
+            s"$left did fail with ${Utils.getClassSimpleName(e.getClass)}, " +
+              s"not ${Utils.getClassSimpleName(ct.runtimeClass)}"
         },
         left match {
           case Success(_) => s"$left failed with ${Utils.getClassSimpleName(ct.runtimeClass)}"
@@ -33,7 +34,7 @@ object TestUtils {
     }
   }
 
-  def failWith[ThrowableT <:Throwable](implicit ct: ClassTag[ThrowableT]) = new FailWith[ThrowableT]
+  def failWith[ThrowableT <: Throwable](implicit ct: ClassTag[ThrowableT]) = new FailWith[ThrowableT]
 
   final implicit class TryPropOps(val self: Try[Any]) extends AnyVal {
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
index 9bd4382..bd0bd2b 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/utils/StringOpsSuite.scala
@@ -30,4 +30,4 @@ class StringOpsSuite extends FreeSpecLike {
       assert("foo".safeTrim == "foo")
     }
   }
-}
\ No newline at end of file
+}