Merge pull request #37 from bnorm/integration

Make samples actually integration tests

.github/workflows/gradle.yml

@@ -17,4 +17,4 @@ jobs:
           java-version: 1.8
 
       - run: ./gradlew build
-      - run: cd sample && ./gradlew build browserDistribution || cd ..
+      - run: cd sample && ./gradlew build

sample/src/commonMain/kotlin/com/bnorm/power/Person.kt

@@ -18,9 +18,10 @@ package com.bnorm.power
 
 data class Person(
   val firstName: String,
-  val lastName: String
+  val lastName: String,
 ) {
   companion object {
     val UNKNOWN = listOf(Person("John", "Doe"), Person("Jane", "Doe"))
+    override fun toString() = "Person.Companion"
   }
 }

sample/src/commonTest/kotlin/com/bnorm/power/PowerAssertTest.kt

@@ -17,17 +17,44 @@
 package com.bnorm.power
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import kotlin.test.assertTrue
 
 class PowerAssertTest {
+
   @Test
   fun assertTrue() {
-    assertTrue(Person.UNKNOWN.size == 1)
+    val error = assertFailsWith<AssertionError> { assertTrue(Person.UNKNOWN.size == 1) }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        Assertion failed
+        assertTrue(Person.UNKNOWN.size == 1)
+                   |      |       |    |
+                   |      |       |    false
+                   |      |       2
+                   |      [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+                   Person.Companion
+      """.trimIndent()
+    )
   }
 
   @Test
   fun require() {
-    require(Person.UNKNOWN.size == 1)
+    val error = assertFailsWith<IllegalArgumentException> { require(Person.UNKNOWN.size == 1) }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        Assertion failed
+        require(Person.UNKNOWN.size == 1)
+                |      |       |    |
+                |      |       |    false
+                |      |       2
+                |      [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+                Person.Companion
+      """.trimIndent()
+    )
   }
 
   @Test
@@ -36,15 +63,52 @@ class PowerAssertTest {
     assert(unknown != null)
     assert(unknown.size == 2)
 
-    val jane: Person
+    val error = assertFailsWith<AssertionError> {
-    val john: Person
+      val jane: Person
-    assertSoftly {
+      val john: Person
-      jane = unknown[0]
+      assertSoftly {
-      assert(jane.firstName == "Jane")
+        jane = unknown[0]
-      assert(jane.lastName == "Doe") { "bad jane last name" }
+        assert(jane.firstName == "Jane")
+        assert(jane.lastName == "Doe") { "bad jane last name" }
 
-      john = unknown[1]
+        john = unknown[1]
-      assert(john.lastName == "Doe" && john.firstName == "John") { "bad john" }
+        assert(john.lastName == "Doe" && john.firstName == "John") { "bad john" }
+      }
     }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        Multiple failed assertions
+      """.trimIndent(),
+    )
+    assertEquals(
+      actual = error.suppressedExceptions.size,
+      expected = 2,
+    )
+    assertEquals(
+      actual = error.suppressedExceptions[0].message,
+      expected = """
+        Assertion failed
+        assert(jane.firstName == "Jane")
+               |    |         |
+               |    |         false
+               |    John
+               Person(firstName=John, lastName=Doe)
+      """.trimIndent(),
+    )
+    assertEquals(
+      actual = error.suppressedExceptions[1].message,
+      expected = """
+        bad john
+        assert(john.lastName == "Doe" && john.firstName == "John") { "bad john" }
+               |    |        |           |    |         |
+               |    |        |           |    |         false
+               |    |        |           |    Jane
+               |    |        |           Person(firstName=Jane, lastName=Doe)
+               |    |        true
+               |    Doe
+               Person(firstName=Jane, lastName=Doe)
+      """.trimIndent(),
+    )
   }
 }

sample/src/jsTest/kotlin/com/bnorm/power/JsPowerAssertTest.kt

@@ -17,10 +17,26 @@
 package com.bnorm.power
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 
 class JsPowerAssertTest {
   @Test
   fun assert() {
-    require(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    val error = assertFailsWith<IllegalArgumentException> {
+      require(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        unknown persons: [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+        require(Person.UNKNOWN.size == 1) { "unknown persons: ${"$"}{Person.UNKNOWN}" }
+                |      |       |    |
+                |      |       |    false
+                |      |       2
+                |      [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+                Person.Companion
+      """.trimIndent(),
+    )
   }
 }

sample/src/jvmTest/kotlin/com/bnorm/power/JvmPowerAssertTest.kt

@@ -17,10 +17,26 @@
 package com.bnorm.power
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 
 class JvmPowerAssertTest {
   @Test
   fun assert() {
-    assert(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    val error = assertFailsWith<AssertionError> {
+      assert(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        unknown persons: [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+        assert(Person.UNKNOWN.size == 1) { "unknown persons: ${"$"}{Person.UNKNOWN}" }
+               |      |       |    |
+               |      |       |    false
+               |      |       2
+               |      [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+               Person.Companion
+      """.trimIndent(),
+    )
   }
 }

sample/src/nativeTest/kotlin/com/bnorm/power/NativePowerAssertTest.kt

@@ -17,10 +17,26 @@
 package com.bnorm.power
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 
 class NativePowerAssertTest {
   @Test
   fun assert() {
-    assert(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    val error = assertFailsWith<AssertionError> {
+      assert(Person.UNKNOWN.size == 1) { "unknown persons: ${Person.UNKNOWN}" }
+    }
+    assertEquals(
+      actual = error.message,
+      expected = """
+        unknown persons: [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+        assert(Person.UNKNOWN.size == 1) { "unknown persons: ${"$"}{Person.UNKNOWN}" }
+               |      |       |    |
+               |      |       |    false
+               |      |       2
+               |      [Person(firstName=John, lastName=Doe), Person(firstName=Jane, lastName=Doe)]
+               Person.Companion
+      """.trimIndent(),
+    )
   }
 }