Extracting query library

1 files changed, 0 insertions, 96 deletions

diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
deleted file mode 100644
index f34f8e1..0000000
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SortingParserSuite.scala
+++ /dev/null
@@ -1,96 +0,0 @@
-package xyz.driver.pdsuicommon.parsers
-
-import xyz.driver.pdsuicommon.parsers.TestUtils._
-import org.scalacheck.Arbitrary.arbitrary
-import org.scalacheck.{Gen, Prop}
-import org.scalatest.prop.Checkers
-import org.scalatest.{FreeSpecLike, MustMatchers}
-
-class SortingParserSuite extends FreeSpecLike with MustMatchers with Checkers {
-
-  "parse" - {
-    "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"))
-      r must failWith[ParseQueryArgException]
-    }
-  }
-
-  private def commonTests(queryGen: Set[String] => Gen[String]): Unit = {
-    "valid" in check {
-      val inputGen: Gen[(Set[String], String)] = for {
-        validDimensions <- dimensionsGen
-        sorting         <- queryGen(validDimensions)
-      } yield (validDimensions, sorting)
-
-      Prop.forAllNoShrink(inputGen) {
-        case (validDimensions, query) =>
-          SortingParser.parse(validDimensions, Seq("sort" -> query)).successProp
-      }
-    }
-
-    "invalid" in check {
-      val inputGen: Gen[(Set[String], String)] = for {
-        validDimensions <- dimensionsGen
-        invalidDimensions <- dimensionsGen.filter { xs =>
-                              xs.intersect(validDimensions).isEmpty
-                            }
-        sorting <- queryGen(invalidDimensions)
-      } yield (validDimensions, sorting)
-
-      Prop.forAllNoShrink(inputGen) {
-        case (validDimensions, query) =>
-          SortingParser.parse(validDimensions, Seq("sort" -> query)).failureProp
-      }
-    }
-  }
-
-  private val dimensionsGen: Gen[Set[String]] = for {
-    unPrefixedSize <- 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)
-    dimensions <- Gen.containerOfN[Set, String](prefixedSize, Gen.identifier)
-  } yield {
-    val prefixedDimensions = prefixes.zip(dimensions).map {
-      case (prefix, dimension) => s"$prefix.$dimension"
-    }
-    unPrefixedDimensions ++ prefixedDimensions
-  }
-
-  private def multipleSortingQueryGen(validDimensions: Set[String]): Gen[String] = {
-    val validDimensionsSeq = validDimensions.toSeq
-    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
-      isAscending <- Gen.containerOfN[Seq, Boolean](dimensions.size, arbitrary[Boolean])
-    } yield {
-      isAscending
-        .zip(dimensions)
-        .map {
-          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
-      }
-
-}