Port some I18n to minutest

testinfected · testinfected · commit 9d599a2ccf95 · 2022-11-01T22:23:16.000-04:00
diff --git a/domain/src/test/kotlin/security/EncodingsTest.kt b/domain/src/test/kotlin/security/EncodingsTest.kt
@@ -2,12 +2,14 @@ package kickstart.security
 
 import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
+import dev.minutest.Tests
 import dev.minutest.junit.JUnit5Minutests
 import dev.minutest.rootContext
 import dev.minutest.test
 import kotlin.test.Test
 
 class HexTest : JUnit5Minutests {
+    @Tests
     fun `encoding and decoding tests`() = rootContext {
         test("encoding to hex") {
             assertThat(
diff --git a/domain/src/test/kotlin/security/PasswordHashTest.kt b/domain/src/test/kotlin/security/PasswordHashTest.kt
@@ -4,11 +4,13 @@ import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
 import com.natpryce.hamkrest.hasElement
 import com.natpryce.hamkrest.hasSize
+import dev.minutest.Tests
 import dev.minutest.junit.JUnit5Minutests
 import dev.minutest.rootContext
 import dev.minutest.test
 
 class PasswordHashTest : JUnit5Minutests {
+    @Tests
     fun salting() = rootContext {
         test("generates a 24 bytes salt") {
             val hash = PasswordHash.create("password")
@@ -26,6 +28,7 @@ class PasswordHashTest : JUnit5Minutests {
             }
         }
 
+        @Tests
         fun hashing() = rootContext {
             test("creates hash from clear text password") {
                 val hash = PasswordHash.create("clear password")
diff --git a/integration/src/test/kotlin/security/UsersDatabaseTest.kt b/integration/src/test/kotlin/security/UsersDatabaseTest.kt
@@ -47,6 +47,7 @@ class Fixture : DatabaseFixture() {
 
 
 class UsersDatabaseTest : JUnit5Minutests {
+    @Tests
     fun tests() = rootContext<Fixture> {
         given {
             Fixture()
diff --git a/webapp/src/test/kotlin/i18n/BundledMessagesTest.kt b/webapp/src/test/kotlin/i18n/BundledMessagesTest.kt
@@ -2,79 +2,81 @@ package i18n
 
 import com.natpryce.hamkrest.*
 import com.natpryce.hamkrest.assertion.assertThat
+import dev.minutest.Tests
+import dev.minutest.given
+import dev.minutest.junit.JUnit5Minutests
+import dev.minutest.rootContext
+import dev.minutest.test
 import kickstart.i18n.BundledMessages
 import kickstart.i18n.loadBundle
 import kotlin.test.Test
 import java.util.*
 
-class BundledMessagesTest {
+class BundledMessagesTest : JUnit5Minutests {
+    @Tests
+    fun tests() = rootContext<BundledMessages> {
+        given { BundledMessages.rootedAt("test/i18n") }
 
-    val bundles = BundledMessages.rootedAt("test/i18n")
+        test("loads translations in specified locale") {
+            val translations = loadBundle("defaults", Locale.FRENCH)
 
-    @Test
-    fun `loads translations in specified locale`() {
-        val translations = bundles.loadBundle("defaults", Locale.FRENCH)
+            assertThat(
+                "translated value", translations.interpolate("app.value"),
+                equalTo("valeur par défaut")
+            )
+        }
 
-        assertThat(
-            "translated value", translations.interpolate("app.value"),
-            equalTo("valeur par défaut")
-        )
-    }
+        test("composes view translations") {
+            val translations = loadBundle("views", "model/page", Locale.ENGLISH)
 
-    @Test
-    fun `composes view translations`() {
-        val translations = bundles.loadBundle("views", "model/page", Locale.ENGLISH)
+            assertThat(
+                "page value", translations.interpolate("page.value"),
+                equalTo("page value")
+            )
+            assertThat(
+                "model value", translations.interpolate("model.value"),
+                equalTo("model default value")
+            )
+            assertThat(
+                "default value", translations.interpolate("views.value"),
+                equalTo("views default value")
+            )
+        }
 
-        assertThat(
-            "page value", translations.interpolate("page.value"),
-            equalTo("page value")
-        )
-        assertThat(
-            "model value", translations.interpolate("model.value"),
-            equalTo("model default value")
-        )
-        assertThat(
-            "default value", translations.interpolate("views.value"),
-            equalTo("views default value")
-        )
-    }
+        test("looks up translation keys, starting with most specific") {
+            fun lookupValueIn(bundleName: String): String? {
+                val translations = loadBundle("views", bundleName, Locale.ENGLISH)
+                return translations.interpolate("value")
+            }
 
-    @Test
-    fun `looks up translation keys, starting with most specific`() {
-        fun lookupValueIn(bundleName: String): String? {
-            val translations = bundles.loadBundle("views", bundleName, Locale.ENGLISH)
-            return translations.interpolate("value")
+            assertThat("page value", lookupValueIn("model/page"), equalTo("page value"))
+            assertThat(
+                "model default value",
+                lookupValueIn("model/other"),
+                equalTo("model default value")
+            )
+            assertThat("views default value", lookupValueIn("other"), equalTo("views default value"))
         }
 
-        assertThat("page value", lookupValueIn("model/page"), equalTo("page value"))
-        assertThat(
-            "model default value",
-            lookupValueIn("model/other"),
-            equalTo("model default value")
-        )
-        assertThat("views default value", lookupValueIn("other"), equalTo("views default value"))
-    }
+        test("ignores missing bundles") {
+            val translations = loadBundle("missing", Locale.ENGLISH)
 
-    @Test
-    fun `ignores missing bundles`() {
-        val translations = bundles.loadBundle("missing", Locale.ENGLISH)
-
-        assertThat(translations.interpolate("key"), absent())
-    }
+            assertThat(translations.interpolate("key"), absent())
+        }
 
-    @Test
-    fun `provides search locations`() {
-        val translations = bundles.loadBundle("views", "model/page", Locale.ENGLISH)
+        test("provides search locations") {
+            val translations = loadBundle("views", "model/page", Locale.ENGLISH)
 
-        val locations = translations.searchPath("views.value")
-            .map { it.description }
+            val locations = translations.searchPath("views.value")
+                .map { it.description }
 
-        assertThat(
-            locations,
-            allOf(
-                hasElement("bundle test/i18n/views/model/page in en"),
-                hasElement("bundle test/i18n/views/model/defaults in en"),
-                hasElement("bundle test/i18n/views/defaults in en"))
-        )
+            assertThat(
+                locations,
+                allOf(
+                    hasElement("bundle test/i18n/views/model/page in en"),
+                    hasElement("bundle test/i18n/views/model/defaults in en"),
+                    hasElement("bundle test/i18n/views/defaults in en"))
+            )
+        }
     }
 }
diff --git a/webapp/src/test/kotlin/i18n/CompositeMessagesTest.kt b/webapp/src/test/kotlin/i18n/CompositeMessagesTest.kt
@@ -3,28 +3,40 @@ package kickstart.i18n
 import com.natpryce.hamkrest.absent
 import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
+import dev.minutest.Tests
+import dev.minutest.given
+import dev.minutest.junit.JUnit5Minutests
+import dev.minutest.rootContext
+import dev.minutest.test
 import kotlin.test.Test
 
-class CompositeMessagesTest {
+class CompositeMessagesTest : JUnit5Minutests {
+    @Tests
+    fun tests() = rootContext<CompositeMessages> {
+        context("when empty") {
+            given { compose() }
 
-    @Test
-    fun `starts as empty`() {
-        val composite = compose()
+            test("can't interpolate anything") {
+                val composite = compose()
 
-        assertThat("any message", composite.interpolate("message"), absent())
-    }
+                assertThat("any message", composite.interpolate("message"), absent())
+            }
+        }
 
-    @Test
-    fun `looks up translation in all composed messages`() {
-        val composite = noMessages + Messages { _, _ -> "translation" }
+        context("when composed") {
+            given { noMessages + Messages { _, _ -> "translation" } }
 
-        assertThat("translated message", composite.interpolate("message"), equalTo("translation"))
-    }
+            test("look up translation in all messages") {
+                assertThat("translated message", interpolate("message"), equalTo("translation"))
+            }
+        }
 
-    @Test
-    fun `looks ups translations in order of addition`() {
-        val composite = Messages { _, _ -> "original" } + Messages { _, _ -> "override" }
+        context("when overridden") {
+            given { Messages { _, _ -> "original" } + Messages { _, _ -> "override" } }
 
-        assertThat("original translation", composite.interpolate("message"), equalTo("original"))
+            test("looks ups translations in order of addition") {
+                assertThat("original translation", interpolate("message"), equalTo("original"))
+            }
+        }
     }
 }
diff --git a/webapp/src/test/kotlin/i18n/I18nTest.kt b/webapp/src/test/kotlin/i18n/I18nTest.kt
@@ -1,32 +1,43 @@
 package kickstart.i18n
 
+import dev.minutest.Tests
+import dev.minutest.given
+import dev.minutest.junit.JUnit5Minutests
+import dev.minutest.rootContext
+import dev.minutest.test
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers.*
 import java.util.*
 import kotlin.test.Test
 
-class I18nTest {
-    val i18n = i18n(Locale.ENGLISH, Locale.CANADA_FRENCH, Locale.FRANCE)
+class I18nTest : JUnit5Minutests {
+    @Tests
+    fun tests() = rootContext<I18n> {
+        context("with single locale") {
+            given { i18n(Locale.ENGLISH) }
 
-    @Test
-    fun `supports its default locale`() {
-        assertThat("default", i18n.defaultLocale, equalTo(Locale.ENGLISH))
-        assertThat("supported locales", i18n.supportedLocales, hasItem(Locale.ENGLISH))
-    }
+            test("supports its default locale") {
+                assertThat("default", defaultLocale, equalTo(Locale.ENGLISH))
+                assertThat("supported locales", supportedLocales, hasItem(Locale.ENGLISH))
+            }
+        }
 
-    @Test
-    fun `supports additional locales`() {
-        assertThat(
-            "supported locales", i18n.supportedLocales,
-            hasItems(Locale.FRANCE, Locale.CANADA_FRENCH, Locale.ENGLISH)
-        )
-    }
+        context("with multiple locales") {
+            given { i18n(Locale.ENGLISH, Locale.CANADA_FRENCH, Locale.FRANCE) }
+
+            test("supports additional locales") {
+                assertThat(
+                    "supported locales", supportedLocales,
+                    hasItems(Locale.FRANCE, Locale.CANADA_FRENCH, Locale.ENGLISH)
+                )
+            }
 
-    @Test
-    fun `computes alternative locales`() {
-        assertThat(
-            "alternatives to english", i18n.alternativeTo(Locale.ENGLISH),
-            containsInAnyOrder(Locale.FRANCE, Locale.CANADA_FRENCH)
-        )
+            test("computes alternative locales") {
+                assertThat(
+                    "alternatives to english", alternativeTo(Locale.ENGLISH),
+                    containsInAnyOrder(Locale.FRANCE, Locale.CANADA_FRENCH)
+                )
+            }
+        }
     }
 }
diff --git a/webapp/src/test/kotlin/i18n/MessageBundleTest.kt b/webapp/src/test/kotlin/i18n/MessageBundleTest.kt
@@ -2,47 +2,53 @@ package kickstart.i18n
 
 import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
+import dev.minutest.Tests
+import dev.minutest.given
+import dev.minutest.junit.JUnit5Minutests
+import dev.minutest.rootContext
+import dev.minutest.test
 import java.time.LocalDate
 import java.time.ZoneOffset
-import kotlin.test.Test
 import java.util.*
 
-class MessageBundleTest {
-    val messages = MessageBundle(object : ListResourceBundle() {
-        override fun getContents(): Array<Array<Any>> {
-            return arrayOf(
-                arrayOf("required", "is required"),
-                arrayOf("out-of-range", "must be between {0, number} and {1, number}"),
-                arrayOf("expired", "must be after {0, date}")
-            )
-        }
+class MessageBundleTest : JUnit5Minutests {
+    @Tests
+    fun tests() = rootContext< MessageBundle> {
+        given {
+            MessageBundle(object : ListResourceBundle() {
+                override fun getContents(): Array<Array<Any>> {
+                    return arrayOf(
+                        arrayOf("required", "is required"),
+                        arrayOf("out-of-range", "must be between {0, number} and {1, number}"),
+                        arrayOf("expired", "must be after {0, date}")
+                    )
+                }
 
-        override fun getLocale(): Locale {
-            return Locale.CANADA_FRENCH
+                override fun getLocale(): Locale {
+                    return Locale.CANADA_FRENCH
+                }
+            })
         }
-    })
 
-    @Test
-    fun `reads messages from resource bundle`() {
-        assertThat("formatted message", messages.interpolate("required"), equalTo("is required"))
-    }
+        test("reads messages from resource bundle") {
+            assertThat("formatted message", interpolate("required"), equalTo("is required"))
+        }
 
-    @Test
-    fun `uses provided parameters as message arguments`() {
-        assertThat(
-            "formatted message",
-            messages.interpolate("out-of-range", 1, 10),
-            equalTo("must be between 1 and 10")
-        )
-    }
+        test("uses provided parameters as message arguments") {
+            assertThat(
+                "formatted message",
+                interpolate("out-of-range", 1, 10),
+                equalTo("must be between 1 and 10")
+            )
+        }
 
-    @Test
-    fun `uses bundle locale when formatting parameters`() {
-        val moment = LocalDate.parse("2021-05-05").atStartOfDay().toInstant(ZoneOffset.ofHours(-4))
-        assertThat(
-            "formatted message",
-            messages.interpolate("expired", Date.from(moment)),
-            equalTo("must be after 5 mai 2021")
-        )
+        test("uses bundle locale when formatting parameters") {
+            val moment = LocalDate.parse("2021-05-05").atStartOfDay().toInstant(ZoneOffset.ofHours(-4))
+            assertThat(
+                "formatted message",
+                interpolate("expired", Date.from(moment)),
+                equalTo("must be after 5 mai 2021")
+            )
+        }
     }
 }
