Update text in test assertions

Author: yevhenii-nadtochii

model/src/test/kotlin/io/spine/validation/MaxPolicySpec.kt

@@ -50,6 +50,6 @@ internal class MaxPolicySpec : CompilationErrorTest() {
         assertCompilationFails(MaxWithEmptyValue::class) { field ->
             shouldContain(MAX)
             shouldContain(field.qualifiedName)
-            shouldContain("because it is empty")
+            shouldContain("the value is empty")
         }
 }

model/src/test/kotlin/io/spine/validation/MinPolicySpec.kt

@@ -50,6 +50,6 @@ internal class MinPolicySpec : CompilationErrorTest() {
         assertCompilationFails(MinWithEmptyValue::class) { field ->
             shouldContain(MIN)
             shouldContain(field.qualifiedName)
-            shouldContain("because it is empty")
+            shouldContain("the value is empty")
         }
 }

model/src/test/kotlin/io/spine/validation/RangePolicySpec.kt

@@ -46,15 +46,15 @@ internal class RangePolicySpec : CompilationErrorTest() {
         assertCompilationFails(message) { field ->
             shouldContain(field.type.name)
             shouldContain(field.qualifiedName)
-            shouldContain("is not supported")
+            shouldContain("a filed of an unsupported type")
         }
 
     @MethodSource("io.spine.validation.RangePolicyTestEnv#messagesWithInvalidDelimiters")
     @ParameterizedTest(name = "with an invalid delimiter in `{0}`")
     fun withInvalidDelimiter(message: KClass<out Message>) =
         assertCompilationFails(message) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("The lower and upper bounds should be separated")
+            shouldContain("the lower and upper bounds must be separated either with")
         }
 
     @MethodSource("io.spine.validation.RangePolicyTestEnv#messagesWithOverflowValues")
@@ -72,69 +72,69 @@ internal class RangePolicySpec : CompilationErrorTest() {
         assertCompilationFails(message) { field ->
             shouldContain(field.qualifiedName)
             shouldContain(value)
-            shouldContain("should be less than the upper")
+            shouldContain("must be less than the upper bound")
         }
 
     @Test
     fun `with an invalid opening symbol`() =
         assertCompilationFails(RangeInvalidOpening::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("The lower bound should begin either")
+            shouldContain("the lower bound must begin either with")
         }
 
     @Test
     fun `with an invalid closing symbol`() =
         assertCompilationFails(RangeInvalidClosing::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("The upper bound should end either")
+            shouldContain("the upper bound must end either with")
         }
 
     @Test
     fun `with integer number specified for lower bound of 'float' field`() =
         assertCompilationFails(RangeInvalidLowerFloat::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `0` bound value")
-            shouldContain("make sure the provided value is a floating-point number")
+            shouldContain("Value: `0`")
+            shouldContain("a floating-point number is required for this field type")
         }
 
     @Test
     fun `with integer number specified for upper bound of 'float' field`() =
         assertCompilationFails(RangeInvalidUpperFloat::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `15` bound value")
-            shouldContain("make sure the provided value is a floating-point number")
+            shouldContain("Value: `15`")
+            shouldContain("a floating-point number is required for this field type")
         }
 
     @Test
     fun `with integer number specified for lower bound of 'double' field`() =
         assertCompilationFails(RangeInvalidLowerDouble::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `0` bound value")
-            shouldContain("make sure the provided value is a floating-point number")
+            shouldContain("Value: `0`")
+            shouldContain("a floating-point number is required for this field type")
         }
 
     @Test
     fun `with integer number specified for upper bound of 'double' field`() =
         assertCompilationFails(RangeInvalidUpperDouble::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `15` bound value")
-            shouldContain("make sure the provided value is a floating-point number")
+            shouldContain("Value: `15`")
+            shouldContain("a floating-point number is required for this field type")
         }
 
     @Test
     fun `with floating-point number specified for lower bound of 'int32' field`() =
         assertCompilationFails(RangeInvalidLowerInt::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `0.0` bound value")
-            shouldContain("make sure the provided value is an integer number")
+            shouldContain("Value: `0.0`") // The bound value.
+            shouldContain("an integer number is required for this field type")
         }
 
     @Test
     fun `with floating-point number specified for upper bound of 'int32' field`() =
         assertCompilationFails(RangeInvalidUpperInt::class) { field ->
             shouldContain(field.qualifiedName)
-            shouldContain("could not parse the `15.0` bound value")
-            shouldContain("make sure the provided value is an integer number")
+            shouldContain("Value: `15.0`") // The bound value.
+            shouldContain("an integer number is required for this field type")
         }
 
     @Test
@@ -151,33 +151,33 @@ internal class RangePolicySpec : CompilationErrorTest() {
         assertCompilationFails(RangeWithNonExistingFieldBound::class) { field ->
             shouldContain(RANGE)
             shouldContain(field.qualifiedName)
-            shouldContain("`timestamp.minutes`")
-            shouldContain("make sure the provided field path is valid")
+            shouldContain("Field path: `timestamp.minutes`")
+            shouldContain("make sure the field path refers to a valid field")
         }
 
     @Test
     fun `with a non-numeric field as a bound`() =
         assertCompilationFails(RangeWithNonNumericFieldBound::class) { field ->
             shouldContain(RANGE)
             shouldContain(field.qualifiedName)
-            shouldContain("cannot use `error.type` field")
-            shouldContain("Only singular numeric fields are supported")
+            shouldContain("Field path: `error.type`")
+            shouldContain("the specified field is not of a numeric type")
         }
 
     @Test
     fun `with a repeated field as a bound`() =
         assertCompilationFails(RangeWithRepeatedFieldBound::class) { field ->
             shouldContain(RANGE)
             shouldContain(field.qualifiedName)
-            shouldContain("cannot use `error_code` field")
-            shouldContain("Only singular numeric fields are supported")
+            shouldContain("Field path: `error_code`")
+            shouldContain("the specified field is not of a numeric type")
         }
 
     @Test
     fun `with self as a bound`() =
         assertCompilationFails(RangeWithSelfReferencing::class) { field ->
             shouldContain(RANGE)
             shouldContain(field.qualifiedName)
-            shouldContain("self-referencing is prohibited")
+            shouldContain("self-referencing is not allowed")
         }
 }