Cleaned up more tests

build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
     id("java")
     id("maven-publish")
     id("org.jetbrains.dokka") version "1.7.10"
-    id("org.jetbrains.kotlinx.kover") version "0.6.0"
+    id("org.jetbrains.kotlinx.kover") version "0.6.1"
     id("org.sonarqube") version "3.4.0.2513"
     id("signing")
     kotlin("jvm") version "1.7.20"

src/test/kotlin/net/thauvin/erik/jokeapi/ExceptionsTest.kt

@@ -32,12 +32,17 @@
 
 package net.thauvin.erik.jokeapi
 
+import assertk.all
 import assertk.assertThat
 import assertk.assertions.index
 import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isNotEmpty
+import assertk.assertions.isNotNull
 import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import assertk.assertions.prop
 import assertk.assertions.size
 import assertk.assertions.startsWith
 import net.thauvin.erik.jokeapi.JokeApi.Companion.fetchUrl
@@ -46,13 +51,8 @@ import net.thauvin.erik.jokeapi.JokeApi.Companion.logger
 import net.thauvin.erik.jokeapi.exceptions.HttpErrorException
 import net.thauvin.erik.jokeapi.exceptions.JokeException
 import net.thauvin.erik.jokeapi.models.Category
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
 import org.junit.jupiter.api.assertThrows
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.ValueSource
@@ -68,17 +68,16 @@ internal class ExceptionsTest {
             getJoke(categories = setOf(Category.CHRISTMAS), search = "foo")
         }
         logger.fine(e.debug())
-        assertAll(
+        assertThat(e, "getJoke(${Category.CHRISTMAS},foo)").all {
-            "JokeException Validation",
+            prop(JokeException::code).isEqualTo(106)
-            { assertEquals(106, e.code) { "getJoke(${Category.CHRISTMAS}, foo).code" } },
+            prop(JokeException::error).isTrue()
-            { assertTrue(e.error) { "getJoke(${Category.CHRISTMAS}, foo).error" } },
+            prop(JokeException::internalError).isFalse()
-            { assertFalse(e.internalError) { "getJoke(${Category.CHRISTMAS}, foo).internalError" } },
+            prop(JokeException::message).isEqualTo("No matching joke found")
-            { assertEquals("No matching joke found", e.message) { "getJoke(${Category.CHRISTMAS}, foo).message" } },
+            prop(JokeException::causedBy).size().isEqualTo(1)
-            { assertThat(e.causedBy, "getJoke(${Category.CHRISTMAS}, foo).causedBy").size().isEqualTo(1) },
+            prop(JokeException::causedBy).index(0).startsWith("No jokes")
-            { assertThat(e.causedBy, "getJoke(${Category.CHRISTMAS}, foo).causedBy").index(0).startsWith("No jokes") },
+            prop(JokeException::additionalInfo).isNotEmpty()
-            { assertThat(e.additionalInfo, "getJoke(${Category.CHRISTMAS}, foo).additionalInfo").isNotEmpty() },
+            prop(JokeException::timestamp).isGreaterThan(0)
-            { assertThat(e.timestamp, "getJoke(${Category.CHRISTMAS}, foo).timestamp").isGreaterThan(0) },
+        }
-        )
     }
 
     @ParameterizedTest(name = "HTTP Status Code: {0}")
@@ -87,11 +86,11 @@ internal class ExceptionsTest {
         val e = assertThrows<HttpErrorException> {
             fetchUrl("$httpStat/$input")
         }
-        assertAll("HttpErrorException Validation",
+        assertThat(e, "fetchUrl($httpStat/$input)").all {
-            { assertEquals(input, e.statusCode) { "fetchUrl($httpStat/$input).statusCode" } },
+            prop(HttpErrorException::statusCode).isEqualTo(input)
-            { assertThat(e.message!!, "fetchUrl($httpStat/$input).message").isNotEmpty() },
+            prop(HttpErrorException::message).isNotNull().isNotEmpty()
-            { assertThat(e.cause!!.message!!, "fetchUrl($httpStat/$input).cause.message").isNotEmpty() }
+            prop(HttpErrorException::cause).isNotNull().assertThat(Throwable::message).isNotNull()
-        )
+        }
     }
 
     @Test
@@ -100,11 +99,11 @@ internal class ExceptionsTest {
         val e = assertThrows<HttpErrorException> {
             fetchUrl("$httpStat/$statusCode")
         }
-        Assertions.assertAll("JokeException Validation",
+        assertThat(e, "fetchUrl($httpStat/$statusCode).statusCode").all {
-            { assertEquals(statusCode, e.statusCode) { "fetchUrl($httpStat/$statusCode).statusCode" } },
+            prop(HttpErrorException::statusCode).isEqualTo(statusCode)
-            { assertThat(e.message!!, "fetchUrl($httpStat/$statusCode).message").isNotEmpty() },
+            prop(HttpErrorException::message).isNotNull().isNotEmpty()
-            { assertThat(e.cause, "fetchUrl($httpStat/$statusCode).statusCode.cause").isNull() }
+            prop(HttpErrorException::cause).isNull()
-        )
+        }
     }
 
     companion object {

src/test/kotlin/net/thauvin/erik/jokeapi/GetJokeTest.kt

@@ -34,12 +34,18 @@ package net.thauvin.erik.jokeapi
 
 import assertk.all
 import assertk.assertThat
+import assertk.assertions.any
 import assertk.assertions.contains
+import assertk.assertions.isBetween
 import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isGreaterThanOrEqualTo
 import assertk.assertions.isIn
 import assertk.assertions.isNotEmpty
+import assertk.assertions.isTrue
+import assertk.assertions.prop
 import assertk.assertions.size
 import net.thauvin.erik.jokeapi.JokeApi.Companion.getJoke
 import net.thauvin.erik.jokeapi.JokeApi.Companion.logger
@@ -47,43 +53,40 @@ import net.thauvin.erik.jokeapi.exceptions.JokeException
 import net.thauvin.erik.jokeapi.models.Category
 import net.thauvin.erik.jokeapi.models.Flag
 import net.thauvin.erik.jokeapi.models.IdRange
+import net.thauvin.erik.jokeapi.models.Joke
 import net.thauvin.erik.jokeapi.models.Language
 import net.thauvin.erik.jokeapi.models.Type
-import org.junit.jupiter.api.Assertions.assertAll
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import java.util.logging.ConsoleHandler
 import java.util.logging.Level
-import kotlin.test.assertContains
 
 internal class GetJokeTest {
     @Test
     fun `Get Joke`() {
         val joke = getJoke()
         logger.fine(joke.toString())
-        assertAll("No Param Joke",
+        assertThat(joke, "getJoke()").all {
-            { assertFalse(joke.error, "getJoke().error") },
+            prop(Joke::error).isFalse()
-            { assertThat(joke.joke, "getJoke().joke").isNotEmpty() },
+            prop(Joke::joke).isNotEmpty()
-            { assertThat(joke.type, "getJoke().type").isIn(Type.SINGLE, Type.TWOPART) },
+            prop(Joke::type).isIn(Type.SINGLE, Type.TWOPART)
-            { assertThat(joke.id, "getJoke().id").isGreaterThanOrEqualTo(0) },
+            prop(Joke::id).isGreaterThanOrEqualTo(0)
-            { assertEquals(Language.EN, joke.language, "getJoke().language") })
+            prop(Joke::language).isEqualTo(Language.EN)
+        }
     }
 
     @Test
     fun `Get Joke without Blacklist Flags`() {
         val joke = getJoke(flags = setOf(Flag.ALL))
-        assertThat(joke.flags, "getJoke(flags=ALL)").isEmpty()
+        assertThat(joke::flags).isEmpty()
     }
 
     @Test
     fun `Get Joke without any Blacklist Flags`() {
         val allFlags = Flag.values().filter { it != Flag.ALL }.toSet()
         val joke = getJoke(flags = allFlags)
-        assertThat(joke.flags, "getJoke(all flags)").isEmpty()
+        assertThat(joke::flags).isEmpty()
     }
 
     @Test
@@ -91,16 +94,14 @@ internal class GetJokeTest {
         val id = 172
         val joke = getJoke(idRange = IdRange(id))
         logger.fine(joke.toString())
-        assertAll("Joke by ID",
+        assertThat(joke, "getJoke($id)").all {
-            {
+            prop(Joke::flags).all {
-                assertThat(joke.flags, "getJoke($id).flags").all {
                 contains(Flag.EXPLICIT)
                 contains(Flag.NSFW)
             }
-            },
+            prop(Joke::id).isEqualTo(172)
-            { assertEquals(172, joke.id) { "getJoke($id).id" } },
+            prop(Joke::category).isEqualTo(Category.PUN)
-            { assertEquals(Category.PUN, joke.category) { "getJoke($id).category" } }
+        }
-        )
     }
 
     @Test
@@ -108,7 +109,7 @@ internal class GetJokeTest {
         val idRange = IdRange(1, 100)
         val joke = getJoke(idRange = idRange)
         logger.fine(joke.toString())
-        assertContains(IntRange(idRange.start, idRange.end), joke.id, "getJoke(${idRange})")
+        assertThat(joke::id).isBetween(idRange.start, idRange.end)
     }
 
     @Test
@@ -116,16 +117,17 @@ internal class GetJokeTest {
         val idRange = IdRange(100, 1)
         val joke = getJoke(idRange = idRange)
         logger.fine(joke.toString())
-        assertFalse(joke.error) { "getJoke(${idRange}.error" }
+        assertThat(joke::error).isFalse()
     }
 
     @Test
     fun `Get Joke with max ID Range`() {
         val idRange = IdRange(1, 30000)
         val e = assertThrows<JokeException> { getJoke(idRange = idRange) }
-        assertAll("Joke w/ max ID Range",
+        assertThat(e, "getJoke{${idRange})").all {
-            { assertTrue(e.error, "getJoke{${idRange}).error") },
+            prop(JokeException::error).isTrue()
-            { assertContains(e.additionalInfo, "ID range", false, "getJoke{${idRange}).additionalInfo") })
+            prop(JokeException::additionalInfo).contains("ID range")
+        }
     }
 
     @Test
@@ -143,7 +145,7 @@ internal class GetJokeTest {
         Category.values().filter { it != Category.ANY }.forEach {
             val joke = getJoke(categories = setOf(it))
             logger.fine(joke.toString())
-            assertEquals(it.value, joke.category.value) { "getJoke($it).category" }
+            assertThat(joke::category, "getJoke($it)").prop(Category::value).isEqualTo(it.value)
         }
     }
 
@@ -151,7 +153,7 @@ internal class GetJokeTest {
     fun `Get Joke with each Languages`() {
         Language.values().forEach {
             val joke = getJoke(language = it)
-            assertEquals(it.value, joke.language.value) { "getJoke(${it}).language" }
+            assertThat(joke::language, "getJoke($it)").prop(Language::value).isEqualTo(it.value)
         }
     }
 
@@ -160,42 +162,51 @@ internal class GetJokeTest {
         val joke = getJoke(
             categories = setOf(Category.DARK), type = Type.SINGLE, idRange = IdRange(178), splitNewLine = false
         )
-        assertContains(joke.joke.toString(), "\n", false, "getJoke(splitNewLine=false)")
+        assertThat(joke::joke, "getJoke(splitNewLine=false)").any {
+            it.contains("\n")
+        }
     }
 
     @Test
     fun `Get Safe Joke`() {
         val joke = getJoke(safe = true)
         logger.fine(joke.toString())
-        assertAll("Safe Joke",
+        assertThat(joke, "getJoke(safe)").all {
-            { assertTrue(joke.safe, "getJoke(safe).safe") },
+            prop(Joke::safe).isTrue()
-            { assertThat(joke.flags, "getJoke(safe).flags").isEmpty() })
+            prop(Joke::flags).isEmpty()
+        }
     }
 
     @Test
     fun `Get Single Joke`() {
         val joke = getJoke(type = Type.SINGLE)
         logger.fine(joke.toString())
-        assertEquals(Type.SINGLE, joke.type) { "getJoke(${Type.SINGLE}).type" }
+        assertThat(joke::type).assertThat(Type.SINGLE)
     }
 
     @Test
     fun `Get Two-Parts Joke`() {
         val joke = getJoke(type = Type.TWOPART)
         logger.fine(joke.toString())
-        assertAll("Two-Parts Joke",
+        assertThat(joke, "getJoke(${Type.TWOPART})").all {
-            { assertEquals(Type.TWOPART, joke.type) { "getJoke(${Type.TWOPART}).type" } },
+            prop(Joke::type).isEqualTo(Type.TWOPART)
-            { assertThat(joke.joke, "getJoke(${Type.TWOPART}).joke").size().isGreaterThan(1) }
+            prop(Joke::joke).size().isGreaterThan(1)
-        )
+        }
     }
 
     @Test
     fun `Get Joke using Search`() {
         val id = 265
+        val search = "his wife"
         val joke =
-            getJoke(search = "his wife", categories = setOf(Category.PROGRAMMING), idRange = IdRange(id), safe = true)
+            getJoke(search = search, categories = setOf(Category.PROGRAMMING), idRange = IdRange(id), safe = true)
         logger.fine(joke.toString())
-        assertEquals(id, joke.id) { "getJoke(his wife).id" }
+        assertThat(joke, "getJoke($search)").all {
+            prop(Joke::id).isEqualTo(id)
+            prop(Joke::joke).any {
+                it.contains(search)
+            }
+        }
     }
 
     companion object {

src/test/kotlin/net/thauvin/erik/jokeapi/GetRawJokeTest.kt

@@ -32,6 +32,7 @@
 
 package net.thauvin.erik.jokeapi
 
+import assertk.all
 import assertk.assertThat
 import assertk.assertions.doesNotContain
 import assertk.assertions.isNotEmpty
@@ -39,10 +40,8 @@ import assertk.assertions.startsWith
 import net.thauvin.erik.jokeapi.JokeApi.Companion.getRawJoke
 import net.thauvin.erik.jokeapi.JokeApi.Companion.logger
 import net.thauvin.erik.jokeapi.models.Format
-import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
 import java.util.logging.ConsoleHandler
 import java.util.logging.Level
 import kotlin.test.assertContains
@@ -51,10 +50,10 @@ internal class GetRawJokeTest {
     @Test
     fun `Get Raw Joke with TXT`() {
         val response = getRawJoke(format = Format.TEXT)
-        assertAll("Plain Text",
+        assertThat(response, "getRawJoke(txt)").all {
-            { assertThat(response, "getRawJoke(txt)").isNotEmpty() },
+            isNotEmpty()
-            { assertFalse(response.startsWith("Error "), "getRawJoke(txt)") }
+            doesNotContain("Error")
-        )
+        }
     }
 
     @Test

src/test/kotlin/net/thauvin/erik/jokeapi/JokeConfigTest.kt

@@ -32,8 +32,12 @@
 
 package net.thauvin.erik.jokeapi
 
+import assertk.all
 import assertk.assertThat
+import assertk.assertions.isBetween
+import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
+import assertk.assertions.prop
 import assertk.assertions.size
 import net.thauvin.erik.jokeapi.JokeApi.Companion.getJoke
 import net.thauvin.erik.jokeapi.JokeApi.Companion.getRawJoke
@@ -42,11 +46,9 @@ import net.thauvin.erik.jokeapi.models.Category
 import net.thauvin.erik.jokeapi.models.Flag
 import net.thauvin.erik.jokeapi.models.Format
 import net.thauvin.erik.jokeapi.models.IdRange
+import net.thauvin.erik.jokeapi.models.Joke
 import net.thauvin.erik.jokeapi.models.Language
 import net.thauvin.erik.jokeapi.models.Type
-import org.junit.jupiter.api.Assertions.assertAll
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
 import java.util.logging.ConsoleHandler
@@ -68,14 +70,14 @@ class JokeConfigTest {
         }.build()
         val joke = getJoke(config)
         logger.fine(joke.toString())
-        assertAll("Two-Parts Joke",
+        assertThat(joke, "config").all {
-            { assertEquals(Type.TWOPART, joke.type, "config.type") },
+            prop(Joke::type).isEqualTo(Type.TWOPART)
-            { assertEquals(joke.category, Category.PROGRAMMING) { "config.category" } },
+            prop(Joke::category).isEqualTo(Category.PROGRAMMING)
-            { assertThat(joke.joke, "config.joke").size().isEqualTo(2) },
+            prop(Joke::joke).size().isEqualTo(2)
-            { assertEquals(joke.language, Language.EN, "config.language") },
+            prop(Joke::language).isEqualTo(Language.EN)
-            { assertTrue(joke.flags.isEmpty(), "config.flags.isEmpty") },
+            prop(Joke::flags).isEmpty()
-            { assertContains(IntRange(id - 2, id + 2), joke.id, "config.id") }
+            prop(Joke::id).isBetween(id - 2, id + 2)
-        )
+        }
     }
 
     @Test