Replace '.get' call with map

This wasn't caught by tests because there were no column reference tests for 'In' rules.

Author: techncl

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/Rule.scala

@@ -54,6 +54,11 @@ abstract class Rule(name: String, val argProviders: ArgProvider*) extends Positi
     else fail(columnIndex, row, schema)
   }
 
+  def argProviderHelper(provider: ArgProvider, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, cellValue: String): (Option[FilePathBase], FilePathBase) = {
+    val ruleValue = provider.referenceValue(columnIndex, row, schema)
+
+    if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.map(_.toLowerCase), cellValue.toLowerCase) else (ruleValue, cellValue)
+  }
 
   def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int,
             row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean =

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/v1_0/Rule.scala

@@ -128,47 +128,36 @@ case class FileExistsRule(pathSubstitutions: List[(String,String)], enforceCaseS
 
 case class InRule(inValue: ArgProvider) extends Rule("in", Seq(inValue): _*) {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean = {
-    val ruleValue = inValue.referenceValue(columnIndex, row, schema)
-
-    val (rv, cv) = if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.get.toLowerCase, cellValue.toLowerCase) else (ruleValue.get, cellValue)
-    rv contains cv
+    val (potentialRv, cv) = argProviderHelper(inValue, columnDefinition, columnIndex, row, schema, cellValue)
+    potentialRv.exists(_.contains(cv))
   }
 }
 
 case class IsRule(isValue: ArgProvider) extends Rule("is", Seq(isValue): _*) {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean]  = None): Boolean = {
-    val ruleValue = isValue.referenceValue(columnIndex, row, schema)
-
-    val (rv, cv) = if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.get.toLowerCase, cellValue.toLowerCase) else (ruleValue.get, cellValue)
-    cv == rv
+    val (potentialRv, cv) = argProviderHelper(isValue, columnDefinition, columnIndex, row, schema, cellValue)
+    potentialRv.contains(cv)
   }
 }
 
-
 case class NotRule(notValue: ArgProvider) extends Rule("not", Seq(notValue): _*) {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema,mayBeLast: Option[Boolean] = None): Boolean = {
-    val ruleValue = notValue.referenceValue(columnIndex, row, schema)
-
-    val (rv, cv) = if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.get.toLowerCase, cellValue.toLowerCase) else (ruleValue.get, cellValue)
-    cv != rv
+    val (potentialRv, cv) = argProviderHelper(notValue, columnDefinition, columnIndex, row, schema, cellValue)
+    !potentialRv.contains(cv)
   }
 }
 
 case class StartsRule(startsValue: ArgProvider) extends Rule("starts", Seq(startsValue): _*) {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean = {
-    val ruleValue = startsValue.referenceValue(columnIndex, row, schema)
-
-    val (rv, cv) = if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.get.toLowerCase, cellValue.toLowerCase) else (ruleValue.get, cellValue)
-    cv startsWith rv
+    val (potentialRv, cv) = argProviderHelper(startsValue, columnDefinition, columnIndex, row, schema, cellValue)
+    potentialRv.exists(rv => cv.startsWith(rv))
   }
 }
 
 case class EndsRule(endsValue: ArgProvider) extends Rule("ends", Seq(endsValue): _*) {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean = {
-    val ruleValue = endsValue.referenceValue(columnIndex, row, schema)
-
-    val (rv, cv) = if (columnDefinition.directives.contains(IgnoreCase())) (ruleValue.get.toLowerCase, cellValue.toLowerCase) else (ruleValue.get, cellValue)
-    cv endsWith rv
+    val (potentialRv, cv) = argProviderHelper(endsValue, columnDefinition, columnIndex, row, schema, cellValue)
+    potentialRv.exists(rv => cv.endsWith(rv))
   }
 }
 

csv-validator-core/src/test/scala/uk/gov/nationalarchives/csv/validator/schema/v1_0/InRuleSpec.scala

@@ -40,6 +40,20 @@ class InRuleSpec extends Specification {
       }
     }
 
+    "succeed if inRule's column reference does exist" in {
+      val inRule = InRule(ColumnReference(NamedColumnIdentifier("column1")))
+
+      inRule.evaluate(0, Row(List(Cell("hello world")), 1), Schema(globalDirsOne, List(ColumnDefinition(NamedColumnIdentifier("column1"))))) mustEqual Validated.Valid(true)
+    }
+
+    "fail if inRule's column reference doesn't exist" in {
+      val inRule = InRule(ColumnReference(NamedColumnIdentifier("nonExistentColumn")))
+
+      inRule.evaluate(0, Row(List(Cell("hello world today")), 1), Schema(globalDirsOne, List(ColumnDefinition(NamedColumnIdentifier("column1"))))) must beLike {
+        case Validated.Invalid(messages) => messages.head mustEqual """in($nonExistentColumn) fails for line: 1, column: column1, value: "hello world today""""
+      }
+    }
+
     "succeed with @ignoreCase" in {
       val inRule = InRule(Literal(Some("hello world")))
       inRule.evaluate(0, Row(List(Cell("hello WORLD")), 1), Schema(globalDirsOne, List(ColumnDefinition(NamedColumnIdentifier("column1"), Nil, List(IgnoreCase()))))) mustEqual Validated.Valid(true)

csv-validator-core/src/test/scala/uk/gov/nationalarchives/csv/validator/schema/v1_0/OrRuleSpec.scala

@@ -67,7 +67,9 @@ class OrRuleSpec extends Specification {
 
       val orRule = OrRule(leftInRule, rightInRule)
 
-      orRule.evaluate(0, Row(List(Cell("UK")), 1), schema) must throwA[NoSuchElementException]
+      orRule.evaluate(0, Row(List(Cell("UK")), 1), schema) must beLike {
+        case Validated.Invalid(messages) => messages.head mustEqual """in($ConfigurableCountry) or in("France") fails for line: 1, column: Country, value: "UK""""
+      }
     }
 
     "succeed when 3 'or' rules valid for right rule" in {