diff options
Diffstat (limited to 'src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala')
-rw-r--r-- | src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala | 260 |
1 files changed, 0 insertions, 260 deletions
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala deleted file mode 100644 index 0209222..0000000 --- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala +++ /dev/null @@ -1,260 +0,0 @@ -package xyz.driver.pdsuicommon.parsers - -import java.util.UUID - -import xyz.driver.pdsuicommon.db.SearchFilterExpr.Dimension -import xyz.driver.pdsuicommon.db.{SearchFilterBinaryOperation, SearchFilterExpr, SearchFilterNAryOperation} -import xyz.driver.pdsuicommon.utils.Implicits.toStringOps -import xyz.driver.pdsuicommon.parsers.TestUtils._ -import fastparse.core.Parsed -import org.scalacheck.Arbitrary.arbitrary -import org.scalacheck.{Gen, Prop} -import org.scalatest.FreeSpecLike -import org.scalatest.prop.Checkers -import xyz.driver.pdsuicommon.db.SearchFilterBinaryOperation.Eq -import xyz.driver.pdsuicommon.db.SearchFilterNAryOperation.In -import xyz.driver.pdsuicommon.utils.Utils -import xyz.driver.pdsuicommon.utils.Utils._ - -import scala.util._ - -object SearchFilterParserSuite { - - class UnexpectedSearchFilterExprException(x: SearchFilterExpr) extends Exception(s"unexpected $x") - -} - -class SearchFilterParserSuite extends FreeSpecLike with Checkers { - - import SearchFilterParserSuite._ - - "parse" - { - "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") - )))) - } - "dimensions" - { - "with table name" in check { - val dimensionGen = { - for (left <- Gen.identifier; right <- Gen.identifier) - yield left -> right - } - Prop.forAllNoShrink(dimensionGen) { - case (left, right) => - val raw = s"$left.$right" - val l = toSnakeCase(left) - val r = toSnakeCase(right) - SearchFilterParser.dimensionParser.parse(raw) match { - case Parsed.Success(Dimension(Some(`l`), `r`), _) => true - case _ => false - } - } - } - "just with field name" in check { - Prop.forAllNoShrink(Gen.identifier) { s => - val databaseS = Utils.toSnakeCase(s) - SearchFilterParser.dimensionParser.parse(s) match { - case Parsed.Success(Dimension(None, `databaseS`), _) => true - case _ => false - } - } - } - } - "atoms" - { - "binary" - { - "common operators" - { - "should be parsed with text values" in check { - import SearchFilterBinaryOperation._ - - val testQueryGen = queryGen( - dimensionGen = Gen.identifier, - opGen = commonBinaryOpsGen, - valueGen = nonEmptyString - ) - - Prop.forAllNoShrink(testQueryGen) { query => - SearchFilterParser - .parse(Seq("filters" -> query)) - .map { - case SearchFilterExpr.Atom.Binary(_, Eq | NotEq | Like, _) => true - case x => throw new UnexpectedSearchFilterExprException(x) - } - .successProp - } - } - } - - "numeric operators" - { - "should not be parsed with text values" in check { - val testQueryGen = queryGen( - dimensionGen = Gen.identifier, - opGen = numericBinaryOpsGen, - valueGen = nonEmptyString.filter { s => - !s.matches("^\\d+$") - } - ) - - Prop.forAllNoShrink(testQueryGen) { query => - SearchFilterParser.parse(Seq("filters" -> query)).failureProp - } - } - } - - "actual recordId" - { - "should not be parsed with numeric values" in { - val filter = SearchFilterParser.parse(Seq("filters" -> "recordId EQ 1")) - assert(filter === Success(SearchFilterExpr.Atom.Binary(Dimension(None, "record_id"), Eq, Long.box(1)))) - } - } - - "actual isVisible boolean" - { - "should not be parsed with boolean values" in { - val filter = SearchFilterParser.parse(Seq("filters" -> "isVisible EQ true")) - assert(filter === Success(SearchFilterExpr.Atom.Binary(Dimension(None, "is_visible"), Eq, Boolean.box(true)))) - } - } - - "actual patientId uuid" - { - "should parse the full UUID as java.util.UUID type" in { - val filter = SearchFilterParser.parse(Seq("filters" -> "patientId EQ 4b4879f7-42b3-4b7c-a685-5c97d9e69e7c")) - assert(filter === Success(SearchFilterExpr.Atom.Binary( - Dimension(None, "patient_id"), Eq, UUID.fromString("4b4879f7-42b3-4b7c-a685-5c97d9e69e7c")))) - } - } - - "all operators" - { - "should be parsed with numeric values" in check { - val testQueryGen = queryGen( - dimensionGen = Gen.identifier, - opGen = allBinaryOpsGen, - valueGen = numericBinaryAtomValuesGen - ) - - Prop.forAllNoShrink(testQueryGen) { query => - SearchFilterParser - .parse(Seq("filters" -> query)) - .map { - case _: SearchFilterExpr.Atom.Binary => true - case x => throw new UnexpectedSearchFilterExprException(x) - } - .successProp - } - } - } - } - - "n-ary" - { - "actual record Ids" - { - "should not be parsed with text values" in { - val filter = SearchFilterParser.parse(Seq("filters" -> "id IN 1,5")) - filter match { - case Success(_) => () - case Failure(t) => t.printStackTrace() - } - assert( - filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5))))) - } - } - - "in" in check { - val testQueryGen = queryGen( - dimensionGen = Gen.identifier, - opGen = Gen.const("in"), - valueGen = inValuesGen - ) - - Prop.forAllNoShrink(testQueryGen) { query => - SearchFilterParser - .parse(Seq("filters" -> query)) - .map { - case SearchFilterExpr.Atom.NAry(_, SearchFilterNAryOperation.In, _) => true - case x => throw new UnexpectedSearchFilterExprException(x) - } - .successProp - } - } - } - } - - "intersections" - { - "should be parsed" in check { - val commonAtomsGen = queryGen( - dimensionGen = Gen.identifier, - opGen = commonBinaryOpsGen, - valueGen = nonEmptyString - ) - - val numericAtomsGen = queryGen( - dimensionGen = Gen.identifier, - opGen = numericBinaryOpsGen, - valueGen = numericBinaryAtomValuesGen - ) - - val allAtomsGen = Gen.oneOf(commonAtomsGen, numericAtomsGen) - val intersectionsGen = Gen.choose(1, 3).flatMap { size => - Gen.containerOfN[Seq, String](size, allAtomsGen) - } - - Prop.forAllNoShrink(intersectionsGen) { queries => - SearchFilterParser.parse(queries.map(query => "filters" -> query)).successProp - } - } - } - } - - 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 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 numericBinaryAtomValuesGen: Gen[String] = arbitrary[Long].map(_.toString) - private val inValueGen: Gen[String] = { - Gen.nonEmptyContainerOf[Seq, Char](inValueCharsGen).map(_.mkString).filter(_.safeTrim.nonEmpty) - } - private val inValuesGen: Gen[String] = Gen.choose(1, 5).flatMap { size => - 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 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 - } - } - -} |