Cleaned up more tests
This commit is contained in:
parent
8c3243fb52
commit
3e3c3db20f
5 changed files with 96 additions and 85 deletions
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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<HttpErrorException> {
|
||||
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<HttpErrorException> {
|
||||
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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
assertThat(joke, "getJoke($id)").all {
|
||||
prop(Joke::flags).all {
|
||||
contains(Flag.EXPLICIT)
|
||||
contains(Flag.NSFW)
|
||||
}
|
||||
},
|
||||
{ assertEquals(172, joke.id) { "getJoke($id).id" } },
|
||||
{ assertEquals(Category.PUN, joke.category) { "getJoke($id).category" } }
|
||||
)
|
||||
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<JokeException> { 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 {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue