Refactored tests scope

rcardin · rcardin · commit 49e4b691c123 · 2023-03-21T22:01:12.000+01:00
diff --git a/src/main/kotlin/in/rcard/assertj/arrowcore/errors/OptionShouldBePresent.kt b/src/main/kotlin/in/rcard/assertj/arrowcore/errors/OptionShouldBePresent.kt
@@ -8,7 +8,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  *
  * @author Riccardo Cardin
  */
-class OptionShouldBePresent :
+internal class OptionShouldBePresent :
     BasicErrorMessageFactory("%nExpecting Option to contain a value but it didn't.".format()) {
     companion object {
 
@@ -17,6 +17,6 @@ class OptionShouldBePresent :
          *
          * @return a error message factory.
          */
-        fun shouldBePresent(): OptionShouldBePresent = OptionShouldBePresent()
+        internal fun shouldBePresent(): OptionShouldBePresent = OptionShouldBePresent()
     }
 }
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_assertThat_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_assertThat_Test.kt
@@ -5,9 +5,9 @@ import arrow.core.right
 import org.assertj.core.api.BDDAssertions.then
 import org.junit.jupiter.api.Test
 
-class EitherAssert_assertThat_Test {
+internal class EitherAssert_assertThat_Test {
     @Test
-    fun `should create an assertion instance when given object is not null`() {
+    internal fun `should create an assertion instance when given object is not null`() {
         // GIVEN
         val rightValue = 42.right()
         // WHEN
@@ -17,7 +17,7 @@ class EitherAssert_assertThat_Test {
     }
 
     @Test
-    fun `should create an assertion instance when given object is null`() {
+    internal fun `should create an assertion instance when given object is null`() {
         // GIVEN
         val rightValue: Either<Nothing, Nothing>? = null
         // WHEN
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeftInstanceOf_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeftInstanceOf_Test.kt
@@ -10,9 +10,9 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages
 import org.junit.jupiter.api.Test
 
-class EitherAssert_containsOnLeftInstanceOf_Test {
+internal class EitherAssert_containsOnLeftInstanceOf_Test {
     @Test
-    fun `should fail if either is null`() {
+    internal fun `should fail if either is null`() {
         val actual: Either<Any, Any>? = null
         Assertions.assertThatThrownBy {
             assertThat(actual).containsLeftInstanceOf(
@@ -24,7 +24,7 @@ class EitherAssert_containsOnLeftInstanceOf_Test {
     }
 
     @Test
-    fun `should fail if either is right`() {
+    internal fun `should fail if either is right`() {
         val actual: Either<Any, String> = "some".right()
         Assertions.assertThatThrownBy {
             assertThat(actual).containsLeftInstanceOf(
@@ -36,20 +36,20 @@ class EitherAssert_containsOnLeftInstanceOf_Test {
     }
 
     @Test
-    fun `should pass if either contains required type on left`() {
+    internal fun `should pass if either contains required type on left`() {
         val actual: Either<String, Nothing> = "something".left()
         assertThat(actual)
             .containsLeftInstanceOf(String::class.java)
     }
 
     @Test
-    fun `should pass if either contains required type subclass on left`() {
+    internal fun `should pass if either contains required type subclass on left`() {
         val actual = Child().left()
         assertThat(actual).containsLeftInstanceOf(Parent::class.java)
     }
 
     @Test
-    fun `should fail if either contains other type on left than required`() {
+    internal fun `should fail if either contains other type on left than required`() {
         val actual: Either<String, Nothing> = "something".left()
         Assertions.assertThatThrownBy {
             assertThat(actual).containsLeftInstanceOf(Int::class.java)
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeft_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeft_Test.kt
@@ -6,48 +6,48 @@ import arrow.core.right
 import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeLeft.Companion.shouldBeLeft
 import `in`.rcard.assertj.arrowcore.errors.EitherShouldContain.Companion.shouldContainOnLeft
 import org.assertj.core.api.Assertions
-import org.assertj.core.util.FailureMessages.*
+import org.assertj.core.util.FailureMessages.actualIsNull
 import org.junit.jupiter.api.Test
 
-class EitherAssert_containsOnLeft_Test {
+internal class EitherAssert_containsOnLeft_Test {
     @Test
-    fun `should fail when either is null`() {
+    internal fun `should fail when either is null`() {
         val leftValue: Either<String, Nothing>? = null
         Assertions.assertThatThrownBy {
             EitherAssert.assertThat(leftValue).containsOnLeft(
-                "something"
+                "something",
             )
         }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(actualIsNull())
     }
 
     @Test
-    fun `should pass if either contains expected value on left side`() {
+    internal fun `should pass if either contains expected value on left side`() {
         val leftValue = "something".left()
         EitherAssert.assertThat(leftValue).containsOnLeft("something")
     }
 
     @Test
-    fun `should fail if either does not contain expected value on left side`() {
+    internal fun `should fail if either does not contain expected value on left side`() {
         val actual: Either<String, Nothing> = "something".left()
         val expectedValue = "nothing"
         Assertions.assertThatThrownBy {
             EitherAssert.assertThat(actual).containsOnLeft(
-                expectedValue
+                expectedValue,
             )
         }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldContainOnLeft(actual, expectedValue).create())
     }
 
     @Test
-    fun `should fail if either is right`() {
+    internal fun `should fail if either is right`() {
         val actual: Either<String, String> = "nothing".right()
         val expectedValue = "something"
         Assertions.assertThatThrownBy {
             EitherAssert.assertThat(actual).containsOnLeft(
-                expectedValue
+                expectedValue,
             )
         }
             .isInstanceOf(AssertionError::class.java)
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRightInstanceOf_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRightInstanceOf_Test.kt
@@ -10,10 +10,10 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages
 import org.junit.jupiter.api.Test
 
-class EitherAssert_containsOnRightInstanceOf_Test {
+internal class EitherAssert_containsOnRightInstanceOf_Test {
 
     @Test
-    fun `should fail if either is null`() {
+    internal fun `should fail if either is null`() {
         val actual: Either<Nothing, Nothing>? = null
         Assertions.assertThatThrownBy {
             assertThat(actual).containsRightInstanceOf(Any::class.java)
@@ -23,7 +23,7 @@ class EitherAssert_containsOnRightInstanceOf_Test {
     }
 
     @Test
-    fun `should fail if either is left`() {
+    internal fun `should fail if either is left`() {
         val actual: Either<String, Nothing> = "some".left()
         Assertions.assertThatThrownBy {
             assertThat(actual).containsRightInstanceOf(Any::class.java)
@@ -33,7 +33,7 @@ class EitherAssert_containsOnRightInstanceOf_Test {
     }
 
     @Test
-    fun should_fail_if_either_contains_other_type_on_right_than_required() {
+    internal fun should_fail_if_either_contains_other_type_on_right_than_required() {
         val actual: Either<Any, Int> = 42.right()
         Assertions.assertThatThrownBy {
             assertThat(actual).containsRightInstanceOf(String::class.java)
@@ -49,13 +49,13 @@ class EitherAssert_containsOnRightInstanceOf_Test {
     }
 
     @Test
-    fun `should pass if either contains required type subclass on right`() {
+    internal fun `should pass if either contains required type subclass on right`() {
         val actual = Child().right()
         assertThat(actual).containsRightInstanceOf(Parent::class.java)
     }
 
     @Test
-    fun `should pass if either contains required type on right`() {
+    internal fun `should pass if either contains required type on right`() {
         val actual: Either<Nothing, String> = "something".right()
         assertThat(actual).containsRightInstanceOf(String::class.java)
     }
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRight_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRight_Test.kt
@@ -9,39 +9,43 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages.actualIsNull
 import org.junit.jupiter.api.Test
 
-class EitherAssert_containsOnRight_Test {
+internal class EitherAssert_containsOnRight_Test {
     @Test
-    fun `should fail when either is null`() {
+    internal fun `should fail when either is null`() {
         val rightValue: Either<Nothing, String>? = null
         Assertions.assertThatThrownBy {
             EitherAssert.assertThat(rightValue).containsOnRight(
-                "something"
+                "something",
             )
         }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(actualIsNull())
     }
 
     @Test
-    fun `should pass if either contains expected value on right side`() {
+    internal fun `should pass if either contains expected value on right side`() {
         val rightValue = "something".right()
         EitherAssert.assertThat(rightValue).containsOnRight("something")
     }
 
     @Test
-    fun should_fail_if_either_is_left() {
+    internal fun should_fail_if_either_is_left() {
         val actual: Either<String, String> = "nothing".left()
         val expectedValue = "something"
-        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).containsOnRight(expectedValue) }
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnRight(expectedValue)
+        }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldBeRight(actual).create())
     }
 
     @Test
-    fun `should fail if either does not contain expected value on right side`() {
+    internal fun `should fail if either does not contain expected value on right side`() {
         val actual: Either<Nothing, String> = "something".right()
         val expectedValue = "nothing"
-        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).containsOnRight(expectedValue) }
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnRight(expectedValue)
+        }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldContainOnRight(actual, expectedValue).create())
     }
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_isLeft_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_isLeft_Test.kt
@@ -8,10 +8,10 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages
 import org.junit.jupiter.api.Test
 
-class EitherAssert_isLeft_Test {
+internal class EitherAssert_isLeft_Test {
 
     @Test
-    fun `should fail if either is null`() {
+    internal fun `should fail if either is null`() {
         // GIVEN
         val leftValue: Either<Nothing, Nothing>? = null
         // WHEN/THEN
@@ -21,15 +21,15 @@ class EitherAssert_isLeft_Test {
     }
 
     @Test
-    fun `should pass if either is left`() {
+    internal fun `should pass if either is left`() {
         // GIVEN
         val leftValue = "Error".left()
         // WHEN/THEN
         EitherAssert.assertThat(leftValue).isLeft()
     }
 
     @Test
-    fun `should fail if either is right`() {
+    internal fun `should fail if either is right`() {
         // GIVEN
         val rightValue = 42.right()
         // WHEN/THEN
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_isRight_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_isRight_Test.kt
@@ -8,10 +8,10 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages.actualIsNull
 import org.junit.jupiter.api.Test
 
-class EitherAssert_isRight_Test {
+internal class EitherAssert_isRight_Test {
 
     @Test
-    fun `should fail if either is null`() {
+    internal fun `should fail if either is null`() {
         // GIVEN
         val rightValue: Either<Nothing, Nothing>? = null
         // WHEN/THEN
@@ -21,15 +21,15 @@ class EitherAssert_isRight_Test {
     }
 
     @Test
-    fun `should pass if either is right`() {
+    internal fun `should pass if either is right`() {
         // GIVEN
         val rightValue = 42.right()
         // WHEN/THEN
         EitherAssert.assertThat(rightValue).isRight()
     }
 
     @Test
-    fun `should fail if either is left`() {
+    internal fun `should fail if either is left`() {
         // GIVEN
         val leftValue = "42".left()
         // WHEN/THEN
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/OptionAssert_assertThat_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/OptionAssert_assertThat_Test.kt
@@ -5,10 +5,10 @@ import arrow.core.some
 import org.assertj.core.api.BDDAssertions.then
 import org.junit.jupiter.api.Test
 
-class OptionAssert_assertThat_Test {
+internal class OptionAssert_assertThat_Test {
 
     @Test
-    fun `should create an assertion instance when given object is not null`() {
+    internal fun `should create an assertion instance when given object is not null`() {
         // GIVEN
         val someValue = 42.some()
         // WHEN
@@ -18,7 +18,7 @@ class OptionAssert_assertThat_Test {
     }
 
     @Test
-    fun `should create an assertion instance when given object is null`() {
+    internal fun `should create an assertion instance when given object is null`() {
         // GIVEN
         val someNullValue: Option<Nothing>? = null
         // WHEN
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/OptionAssert_isDefined_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/OptionAssert_isDefined_Test.kt
@@ -9,21 +9,21 @@ import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages.actualIsNull
 import org.junit.jupiter.api.Test
 
-class OptionAssert_isDefined_Test {
+internal class OptionAssert_isDefined_Test {
     @Test
-    fun `should pass when Option is present`() {
+    internal fun `should pass when Option is present`() {
         assertThat("present".some()).isDefined()
     }
 
     @Test
-    fun `should fail when Option is empty`() {
+    internal fun `should fail when Option is empty`() {
         Assertions.assertThatThrownBy { assertThat(None).isDefined() }
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldBePresent().create())
     }
 
     @Test
-    fun `should fail when Option is null`() {
+    internal fun `should fail when Option is null`() {
         val nullOption: Option<Nothing>? = null
         Assertions.assertThatThrownBy { assertThat(nullOption).isDefined() }
             .isInstanceOf(AssertionError::class.java)

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import org.assertj.core.error.BasicErrorMessageFactory`
`8`	`8`	`*`
`9`	`9`	`* @author Riccardo Cardin`
`10`	`10`	`*/`
`11`		`-class OptionShouldBePresent :`
	`11`	`+internal class OptionShouldBePresent :`
`12`	`12`	`BasicErrorMessageFactory("%nExpecting Option to contain a value but it didn't.".format()) {`
`13`	`13`	`companion object {`
`14`	`14`
`@@ -17,6 +17,6 @@ class OptionShouldBePresent :`
`17`	`17`	`*`
`18`	`18`	`* @return a error message factory.`
`19`	`19`	`*/`
`20`		`- fun shouldBePresent(): OptionShouldBePresent = OptionShouldBePresent()`
	`20`	`+ internal fun shouldBePresent(): OptionShouldBePresent = OptionShouldBePresent()`
`21`	`21`	`}`
`22`	`22`	`}`