From 3e3c3db20ff60ffe26f416bc867dadb745ed2dd2 Mon Sep 17 00:00:00 2001 From: "Erik C. Thauvin" Date: Tue, 4 Oct 2022 12:54:09 -0700 Subject: [PATCH] Cleaned up more tests --- build.gradle.kts | 2 +- .../thauvin/erik/jokeapi/ExceptionsTest.kt | 51 +++++----- .../net/thauvin/erik/jokeapi/GetJokeTest.kt | 93 +++++++++++-------- .../thauvin/erik/jokeapi/GetRawJokeTest.kt | 11 +-- .../thauvin/erik/jokeapi/JokeConfigTest.kt | 24 ++--- 5 files changed, 96 insertions(+), 85 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index e433258..3064cd2 100644 --- a/build.gradle.kts +++ b/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" diff --git a/src/test/kotlin/net/thauvin/erik/jokeapi/ExceptionsTest.kt b/src/test/kotlin/net/thauvin/erik/jokeapi/ExceptionsTest.kt index e28cc7a..b23a5b2 100644 --- a/src/test/kotlin/net/thauvin/erik/jokeapi/ExceptionsTest.kt +++ b/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( - "JokeException Validation", - { assertEquals(106, e.code) { "getJoke(${Category.CHRISTMAS}, foo).code" } }, - { assertTrue(e.error) { "getJoke(${Category.CHRISTMAS}, foo).error" } }, - { assertFalse(e.internalError) { "getJoke(${Category.CHRISTMAS}, foo).internalError" } }, - { assertEquals("No matching joke found", e.message) { "getJoke(${Category.CHRISTMAS}, foo).message" } }, - { assertThat(e.causedBy, "getJoke(${Category.CHRISTMAS}, foo).causedBy").size().isEqualTo(1) }, - { assertThat(e.causedBy, "getJoke(${Category.CHRISTMAS}, foo).causedBy").index(0).startsWith("No jokes") }, - { assertThat(e.additionalInfo, "getJoke(${Category.CHRISTMAS}, foo).additionalInfo").isNotEmpty() }, - { assertThat(e.timestamp, "getJoke(${Category.CHRISTMAS}, foo).timestamp").isGreaterThan(0) }, - ) + assertThat(e, "getJoke(${Category.CHRISTMAS},foo)").all { + prop(JokeException::code).isEqualTo(106) + prop(JokeException::error).isTrue() + prop(JokeException::internalError).isFalse() + prop(JokeException::message).isEqualTo("No matching joke found") + prop(JokeException::causedBy).size().isEqualTo(1) + prop(JokeException::causedBy).index(0).startsWith("No jokes") + prop(JokeException::additionalInfo).isNotEmpty() + prop(JokeException::timestamp).isGreaterThan(0) + } } @ParameterizedTest(name = "HTTP Status Code: {0}") @@ -87,11 +86,11 @@ internal class ExceptionsTest { val e = assertThrows { fetchUrl("$httpStat/$input") } - assertAll("HttpErrorException Validation", - { assertEquals(input, e.statusCode) { "fetchUrl($httpStat/$input).statusCode" } }, - { assertThat(e.message!!, "fetchUrl($httpStat/$input).message").isNotEmpty() }, - { assertThat(e.cause!!.message!!, "fetchUrl($httpStat/$input).cause.message").isNotEmpty() } - ) + assertThat(e, "fetchUrl($httpStat/$input)").all { + prop(HttpErrorException::statusCode).isEqualTo(input) + prop(HttpErrorException::message).isNotNull().isNotEmpty() + prop(HttpErrorException::cause).isNotNull().assertThat(Throwable::message).isNotNull() + } } @Test @@ -100,11 +99,11 @@ internal class ExceptionsTest { val e = assertThrows { fetchUrl("$httpStat/$statusCode") } - Assertions.assertAll("JokeException Validation", - { assertEquals(statusCode, e.statusCode) { "fetchUrl($httpStat/$statusCode).statusCode" } }, - { assertThat(e.message!!, "fetchUrl($httpStat/$statusCode).message").isNotEmpty() }, - { assertThat(e.cause, "fetchUrl($httpStat/$statusCode).statusCode.cause").isNull() } - ) + assertThat(e, "fetchUrl($httpStat/$statusCode).statusCode").all { + prop(HttpErrorException::statusCode).isEqualTo(statusCode) + prop(HttpErrorException::message).isNotNull().isNotEmpty() + prop(HttpErrorException::cause).isNull() + } } companion object { diff --git a/src/test/kotlin/net/thauvin/erik/jokeapi/GetJokeTest.kt b/src/test/kotlin/net/thauvin/erik/jokeapi/GetJokeTest.kt index edc85ff..deda3a7 100644 --- a/src/test/kotlin/net/thauvin/erik/jokeapi/GetJokeTest.kt +++ b/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", - { assertFalse(joke.error, "getJoke().error") }, - { assertThat(joke.joke, "getJoke().joke").isNotEmpty() }, - { assertThat(joke.type, "getJoke().type").isIn(Type.SINGLE, Type.TWOPART) }, - { assertThat(joke.id, "getJoke().id").isGreaterThanOrEqualTo(0) }, - { assertEquals(Language.EN, joke.language, "getJoke().language") }) + assertThat(joke, "getJoke()").all { + prop(Joke::error).isFalse() + prop(Joke::joke).isNotEmpty() + prop(Joke::type).isIn(Type.SINGLE, Type.TWOPART) + prop(Joke::id).isGreaterThanOrEqualTo(0) + 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.flags, "getJoke($id).flags").all { - contains(Flag.EXPLICIT) - contains(Flag.NSFW) - } - }, - { assertEquals(172, joke.id) { "getJoke($id).id" } }, - { assertEquals(Category.PUN, joke.category) { "getJoke($id).category" } } - ) + assertThat(joke, "getJoke($id)").all { + prop(Joke::flags).all { + contains(Flag.EXPLICIT) + contains(Flag.NSFW) + } + prop(Joke::id).isEqualTo(172) + prop(Joke::category).isEqualTo(Category.PUN) + } } @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 { getJoke(idRange = idRange) } - assertAll("Joke w/ max ID Range", - { assertTrue(e.error, "getJoke{${idRange}).error") }, - { assertContains(e.additionalInfo, "ID range", false, "getJoke{${idRange}).additionalInfo") }) + assertThat(e, "getJoke{${idRange})").all { + prop(JokeException::error).isTrue() + 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", - { assertTrue(joke.safe, "getJoke(safe).safe") }, - { assertThat(joke.flags, "getJoke(safe).flags").isEmpty() }) + assertThat(joke, "getJoke(safe)").all { + prop(Joke::safe).isTrue() + 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", - { assertEquals(Type.TWOPART, joke.type) { "getJoke(${Type.TWOPART}).type" } }, - { assertThat(joke.joke, "getJoke(${Type.TWOPART}).joke").size().isGreaterThan(1) } - ) + assertThat(joke, "getJoke(${Type.TWOPART})").all { + prop(Joke::type).isEqualTo(Type.TWOPART) + 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 { diff --git a/src/test/kotlin/net/thauvin/erik/jokeapi/GetRawJokeTest.kt b/src/test/kotlin/net/thauvin/erik/jokeapi/GetRawJokeTest.kt index b55a2d1..9ec9f0d 100644 --- a/src/test/kotlin/net/thauvin/erik/jokeapi/GetRawJokeTest.kt +++ b/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)").isNotEmpty() }, - { assertFalse(response.startsWith("Error "), "getRawJoke(txt)") } - ) + assertThat(response, "getRawJoke(txt)").all { + isNotEmpty() + doesNotContain("Error") + } } @Test diff --git a/src/test/kotlin/net/thauvin/erik/jokeapi/JokeConfigTest.kt b/src/test/kotlin/net/thauvin/erik/jokeapi/JokeConfigTest.kt index c8959b0..ef1109e 100644 --- a/src/test/kotlin/net/thauvin/erik/jokeapi/JokeConfigTest.kt +++ b/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", - { assertEquals(Type.TWOPART, joke.type, "config.type") }, - { assertEquals(joke.category, Category.PROGRAMMING) { "config.category" } }, - { assertThat(joke.joke, "config.joke").size().isEqualTo(2) }, - { assertEquals(joke.language, Language.EN, "config.language") }, - { assertTrue(joke.flags.isEmpty(), "config.flags.isEmpty") }, - { assertContains(IntRange(id - 2, id + 2), joke.id, "config.id") } - ) + assertThat(joke, "config").all { + prop(Joke::type).isEqualTo(Type.TWOPART) + prop(Joke::category).isEqualTo(Category.PROGRAMMING) + prop(Joke::joke).size().isEqualTo(2) + prop(Joke::language).isEqualTo(Language.EN) + prop(Joke::flags).isEmpty() + prop(Joke::id).isBetween(id - 2, id + 2) + } } @Test