From 3287e42ab64e94d81406d89415be04c254789b7f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 19 May 2023 07:59:26 +0000 Subject: [PATCH] Bump assertk-jvm from 0.25 to 0.26.1 [BREAKING CHANGE] Bumps [assertk-jvm](https://github.com/willowtreeapps/assertk) from 0.25 to 0.26.1. - [Release notes](https://github.com/willowtreeapps/assertk/releases) - [Changelog](https://github.com/willowtreeapps/assertk/blob/main/CHANGELOG.md) - [Commits](https://github.com/willowtreeapps/assertk/compare/v0.25...v0.26.1) Remove usages of deprecated `assertThat {}`. Bump version due to deprecation. --- updated-dependencies: - dependency-name: com.willowtreeapps.assertk:assertk-jvm dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- build-resources/pom.xml | 2 +- config/pom.xml | 2 +- db/pom.xml | 2 +- .../trib3/db/jooqext/ResultQueryFlowTest.kt | 7 +- graphql/pom.xml | 2 +- .../execution/CoroutineBatchLoadersTest.kt | 6 +- .../execution/LeakyCauldronHooksTest.kt | 88 +++++++++++-------- .../GraphQLResourceIntegrationTest.kt | 6 +- .../graphql/resources/GraphQLResourceTest.kt | 8 +- .../resources/GraphQLSseResourceTest.kt | 18 ++-- json/pom.xml | 2 +- .../kotlin/com/trib3/json/ObjectMapperTest.kt | 14 +-- parent-pom/pom.xml | 4 +- pom.xml | 2 +- server/pom.xml | 2 +- .../CoroutineInvocationHandlerTest.kt | 6 +- .../server/filters/AdminAuthFilterTest.kt | 26 +++--- .../filters/CookieTokenAuthFilterTest.kt | 22 ++--- testing/pom.xml | 2 +- .../kotlin/com/trib3/testing/LeakyMockTest.kt | 24 ++--- .../com/trib3/testing/db/DAOTestBaseTest.kt | 10 +-- .../JettyWebTestContainerFactoryTest.kt | 14 +-- 22 files changed, 143 insertions(+), 126 deletions(-) diff --git a/build-resources/pom.xml b/build-resources/pom.xml index da81643c0..87e39350d 100644 --- a/build-resources/pom.xml +++ b/build-resources/pom.xml @@ -7,7 +7,7 @@ com.trib3 build-resources - 2.1-SNAPSHOT + 2.2-SNAPSHOT Build Resources Resources for use during the build process diff --git a/config/pom.xml b/config/pom.xml index f2c8dad58..0bc310d25 100644 --- a/config/pom.xml +++ b/config/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/db/pom.xml b/db/pom.xml index e6b4ff633..b79cec48c 100644 --- a/db/pom.xml +++ b/db/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/db/src/test/kotlin/com/trib3/db/jooqext/ResultQueryFlowTest.kt b/db/src/test/kotlin/com/trib3/db/jooqext/ResultQueryFlowTest.kt index 9665408a9..52ead348e 100644 --- a/db/src/test/kotlin/com/trib3/db/jooqext/ResultQueryFlowTest.kt +++ b/db/src/test/kotlin/com/trib3/db/jooqext/ResultQueryFlowTest.kt @@ -1,14 +1,13 @@ package com.trib3.db.jooqext +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEmpty import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.delay -import kotlinx.coroutines.flow.collect import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.toList import kotlinx.coroutines.launch @@ -92,9 +91,9 @@ class ResultQueryFlowTest { val list = mutableListOf() runBlocking { val collectJob = launch { - assertThat { + assertFailure { query.consumeAsFlow().map { it["value"] as Int }.toList(list) - }.isFailure().isInstanceOf(RuntimeException::class.java).hasMessage("cancelled") + }.isInstanceOf(RuntimeException::class.java).hasMessage("cancelled") } launch { iterateLatch.await() // wait for collection to start diff --git a/graphql/pom.xml b/graphql/pom.xml index 999d62b53..0261d6a9e 100644 --- a/graphql/pom.xml +++ b/graphql/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/graphql/src/test/kotlin/com/trib3/graphql/execution/CoroutineBatchLoadersTest.kt b/graphql/src/test/kotlin/com/trib3/graphql/execution/CoroutineBatchLoadersTest.kt index c93b23135..5fc4158f8 100644 --- a/graphql/src/test/kotlin/com/trib3/graphql/execution/CoroutineBatchLoadersTest.kt +++ b/graphql/src/test/kotlin/com/trib3/graphql/execution/CoroutineBatchLoadersTest.kt @@ -1,8 +1,8 @@ package com.trib3.graphql.execution +import assertk.assertFailure import assertk.assertThat import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isLessThan import assertk.assertions.messageContains import com.expediagroup.graphql.generator.extensions.get @@ -80,9 +80,9 @@ class CoroutineBatchLoadersTest { val loading = loader.load(setOf("1", "2", "3"), mockEnv) this.coroutineContext[Job]?.cancelChildren() val startAwaitTime = System.currentTimeMillis() - assertThat { + assertFailure { loading.await() - }.isFailure().messageContains("was cancelled") + }.messageContains("was cancelled") // ensure the delay() is not hit, but allow for slow test machines assertThat(System.currentTimeMillis() - startAwaitTime).isLessThan(19000) EasyMock.verify(mockEnv) diff --git a/graphql/src/test/kotlin/com/trib3/graphql/execution/LeakyCauldronHooksTest.kt b/graphql/src/test/kotlin/com/trib3/graphql/execution/LeakyCauldronHooksTest.kt index c505af4d7..a8217de80 100644 --- a/graphql/src/test/kotlin/com/trib3/graphql/execution/LeakyCauldronHooksTest.kt +++ b/graphql/src/test/kotlin/com/trib3/graphql/execution/LeakyCauldronHooksTest.kt @@ -1,8 +1,8 @@ package com.trib3.graphql.execution +import assertk.assertFailure import assertk.assertThat import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isSuccess import com.expediagroup.graphql.generator.SchemaGeneratorConfig @@ -95,13 +95,15 @@ class LeakyCauldronHooksTest { assertThat(result["year"]).isEqualTo("2020") assertValidationErrors("""query {year(y:123)}""", """query {year(y:"123-45")}""") - assertThat { + assertFailure { YEAR_SCALAR.coercing.serialize(123, GraphQLContext.getDefault(), Locale.getDefault()) - }.isFailure().isInstanceOf(CoercingSerializeException::class) + }.isInstanceOf(CoercingSerializeException::class) - assertThat { - YEAR_SCALAR.coercing.serialize(Year.of(2019), GraphQLContext.getDefault(), Locale.getDefault()) - }.isSuccess().isEqualTo("2019") + assertThat( + runCatching { + YEAR_SCALAR.coercing.serialize(Year.of(2019), GraphQLContext.getDefault(), Locale.getDefault()) + }, + ).isSuccess().isEqualTo("2019") } @Test @@ -120,17 +122,19 @@ class LeakyCauldronHooksTest { assertThat(result["quarter"]).isEqualTo("2019-Q2") assertValidationErrors("""query {quarter(q:123)}""", """query {quarter(q:"123")}""") - assertThat { + assertFailure { YEAR_QUARTER_SCALAR.coercing.serialize(123, GraphQLContext.getDefault(), Locale.getDefault()) - }.isFailure().isInstanceOf(CoercingSerializeException::class) - - assertThat { - YEAR_QUARTER_SCALAR.coercing.serialize( - YearQuarter.of(2019, 2), - GraphQLContext.getDefault(), - Locale.getDefault(), - ) - }.isSuccess().isEqualTo("2019-Q2") + }.isInstanceOf(CoercingSerializeException::class) + + assertThat( + runCatching { + YEAR_QUARTER_SCALAR.coercing.serialize( + YearQuarter.of(2019, 2), + GraphQLContext.getDefault(), + Locale.getDefault(), + ) + }, + ).isSuccess().isEqualTo("2019-Q2") } @Test @@ -149,17 +153,19 @@ class LeakyCauldronHooksTest { assertThat(result["month"]).isEqualTo("2019-02") assertValidationErrors("""query {month(m:123)}""", """query {month(m:"123")}""") - assertThat { + assertFailure { YEAR_MONTH_SCALAR.coercing.serialize(123, GraphQLContext.getDefault(), Locale.getDefault()) - }.isFailure().isInstanceOf(CoercingSerializeException::class) - - assertThat { - YEAR_MONTH_SCALAR.coercing.serialize( - YearMonth.of(2019, 10), - GraphQLContext.getDefault(), - Locale.getDefault(), - ) - }.isSuccess().isEqualTo("2019-10") + }.isInstanceOf(CoercingSerializeException::class) + + assertThat( + runCatching { + YEAR_MONTH_SCALAR.coercing.serialize( + YearMonth.of(2019, 10), + GraphQLContext.getDefault(), + Locale.getDefault(), + ) + }, + ).isSuccess().isEqualTo("2019-10") } @Test @@ -179,17 +185,19 @@ class LeakyCauldronHooksTest { assertThat(result["localDateTime"]).isEqualTo("2019-10-31T01:01:00.000") assertValidationErrors("""query {localDateTime(l:123)}""", """query {localDateTime(l:"123")}""") - assertThat { + assertFailure { LOCAL_DATETIME_SCALAR.coercing.serialize(123, GraphQLContext.getDefault(), Locale.getDefault()) - }.isFailure().isInstanceOf(CoercingSerializeException::class) - - assertThat { - LOCAL_DATETIME_SCALAR.coercing.serialize( - LocalDateTime.of(2019, 10, 31, 1, 1), - GraphQLContext.getDefault(), - Locale.getDefault(), - ) - }.isSuccess().isEqualTo("2019-10-31T01:01:00.000") + }.isInstanceOf(CoercingSerializeException::class) + + assertThat( + runCatching { + LOCAL_DATETIME_SCALAR.coercing.serialize( + LocalDateTime.of(2019, 10, 31, 1, 1), + GraphQLContext.getDefault(), + Locale.getDefault(), + ) + }, + ).isSuccess().isEqualTo("2019-10-31T01:01:00.000") } @Test @@ -260,9 +268,11 @@ class LeakyCauldronHooksTest { fun testUUIDGeneration() { val result = graphQL.execute("""query { newuuid }""") .getData>() - assertThat { - UUID.fromString(result["newuuid"]) - }.isSuccess() + assertThat( + runCatching { + UUID.fromString(result["newuuid"]) + }, + ).isSuccess() } @Test diff --git a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceIntegrationTest.kt b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceIntegrationTest.kt index 0c33400d9..d566a4538 100644 --- a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceIntegrationTest.kt +++ b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceIntegrationTest.kt @@ -1,9 +1,9 @@ package com.trib3.graphql.resources +import assertk.assertFailure import assertk.assertThat import assertk.assertions.endsWith import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isNotNull import assertk.assertions.isNull import assertk.assertions.messageContains @@ -147,7 +147,7 @@ class GraphQLResourceIntegrationTest : ResourceTestBase() { try { val uri = resource.target("/graphql").queryParam("fail", "true").uriBuilder.scheme("ws").build() val adapter = WebSocketAdapter() - assertThat { + assertFailure { client.connect( adapter, uri, @@ -155,7 +155,7 @@ class GraphQLResourceIntegrationTest : ResourceTestBase() { it.cookies = listOf(HttpCookie("authCookie", "user")) }, ).get() - }.isFailure().messageContains("Failed to upgrade") + }.messageContains("Failed to upgrade") } finally { client.stop() } diff --git a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceTest.kt b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceTest.kt index a67796205..77f0230e2 100644 --- a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceTest.kt +++ b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLResourceTest.kt @@ -301,8 +301,10 @@ class GraphQLResourceTest { EasyMock.expect(mockContext[Job]).andReturn(null).anyTimes() EasyMock.replay(mockScope, mockContext) resource.runningFutures["987"] = mockScope - assertThat { - resource.cancel(Optional.empty(), "987") - }.isSuccess() + assertThat( + runCatching { + resource.cancel(Optional.empty(), "987") + }, + ).isSuccess() } } diff --git a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLSseResourceTest.kt b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLSseResourceTest.kt index 65a36bc1a..dc2923e53 100644 --- a/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLSseResourceTest.kt +++ b/graphql/src/test/kotlin/com/trib3/graphql/resources/GraphQLSseResourceTest.kt @@ -67,14 +67,16 @@ class GraphQLSseResourceTest { val mockSse = LeakyMock.mock() EasyMock.expect(mockSse.newEventBuilder()).andReturn(OutboundEvent.Builder()).anyTimes() EasyMock.replay(mockSink, mockSse) - assertThat { - resource.querySse( - mockSink, - mockSse, - Optional.of(principal), - GraphQLRequest("query"), - ) - }.isSuccess() + assertThat( + runCatching { + resource.querySse( + mockSink, + mockSse, + Optional.of(principal), + GraphQLRequest("query"), + ) + }, + ).isSuccess() assertThat(eventCapture.values[0].name).isEqualTo("next") assertThat(eventCapture.values[0].data.toString()).contains(""""message":"fake error"""") assertThat(eventCapture.values[1].name).isEqualTo("complete") diff --git a/json/pom.xml b/json/pom.xml index 910d7324a..0571f7bbd 100644 --- a/json/pom.xml +++ b/json/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/json/src/test/kotlin/com/trib3/json/ObjectMapperTest.kt b/json/src/test/kotlin/com/trib3/json/ObjectMapperTest.kt index c50efdfc7..f9e33bc1a 100644 --- a/json/src/test/kotlin/com/trib3/json/ObjectMapperTest.kt +++ b/json/src/test/kotlin/com/trib3/json/ObjectMapperTest.kt @@ -1,11 +1,11 @@ package com.trib3.json import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.doesNotContain import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull @@ -129,9 +129,9 @@ class ObjectMapperTest assertThat(mapper.writeValueAsString(yq)).isEqualTo("\"2010-Q1\"") assertThat(mapper.readValue("\"2010-Q1\"")).isEqualTo(yq) assertThat(mapper.readValue("\"\"")).isNull() - assertThat { + assertFailure { mapper.readValue("123") - }.isFailure().all { + }.all { isInstanceOf(JsonMappingException::class) message().isNotNull().contains("Expected VALUE_STRING for YearQuarter but saw") } @@ -151,9 +151,9 @@ class ObjectMapperTest val map = mapOf(YearQuarter.of(2010, 1) to YearQuarter.of(2011, 2)) assertThat(mapper.writeValueAsString(map)).isEqualTo("{\"2010-Q1\":\"2011-Q2\"}") assertThat(mapper.readValue>("{\"2010-Q1\":\"2011-Q2\"}")).isEqualTo(map) - assertThat { + assertFailure { mapper.readValue>("{\"abc\": \"2011-Q2\"}") - }.isFailure().all { + }.all { isInstanceOf(JsonMappingException::class) message().isNotNull().contains("Unexpected quarter") } @@ -171,9 +171,9 @@ class ObjectMapperTest @Test fun testNeedInjectionForUnDeserializable() { - assertThat { + assertFailure { mapper.readValue("""{"foo": "blah"}""") - }.isFailure() + } } @Test diff --git a/parent-pom/pom.xml b/parent-pom/pom.xml index 573ea2e53..cff584e26 100644 --- a/parent-pom/pom.xml +++ b/parent-pom/pom.xml @@ -6,7 +6,7 @@ 4.0.0 com.trib3 parent-pom - 2.1-SNAPSHOT + 2.2-SNAPSHOT pom Trib3 parent pom @@ -46,7 +46,7 @@ 1.3.5 1.10.13 0.9.0 - 0.25 + 0.26.1 2.20.79 1.14.5 3.1.6 diff --git a/pom.xml b/pom.xml index 93e4b6808..52712e7e8 100644 --- a/pom.xml +++ b/pom.xml @@ -8,7 +8,7 @@ com.trib3 parent-pom - 2.1-SNAPSHOT + 2.2-SNAPSHOT parent-pom/pom.xml diff --git a/server/pom.xml b/server/pom.xml index 29af0a7ed..26b45c308 100644 --- a/server/pom.xml +++ b/server/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/server/src/test/kotlin/com/trib3/server/coroutine/CoroutineInvocationHandlerTest.kt b/server/src/test/kotlin/com/trib3/server/coroutine/CoroutineInvocationHandlerTest.kt index 6824e158f..060841b10 100644 --- a/server/src/test/kotlin/com/trib3/server/coroutine/CoroutineInvocationHandlerTest.kt +++ b/server/src/test/kotlin/com/trib3/server/coroutine/CoroutineInvocationHandlerTest.kt @@ -1,9 +1,9 @@ package com.trib3.server.coroutine +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isLessThan import assertk.assertions.isNotNull import assertk.assertions.isNull @@ -444,8 +444,8 @@ class CoroutineInvocationHandlerTest : ResourceTestBase - proceeded = true - } - }.isSuccess() + assertThat( + runCatching { + filter.doFilter(mockRequest, mockResponse) { _, _ -> + proceeded = true + } + }, + ).isSuccess() assertThat(proceeded).isTrue() } @@ -73,11 +75,11 @@ class AdminAuthFilterTest { val filter = AdminAuthFilter() filter.init(mockFilterConfig) var proceeded = false - assertThat { + assertFailure { filter.doFilter(mockRequest, mockResponse) { _, _ -> proceeded = true } - }.isFailure().hasMessage("Invalid credentials") + }.hasMessage("Invalid credentials") assertThat(proceeded).isFalse() EasyMock.verify(mockResponse) @@ -102,11 +104,11 @@ class AdminAuthFilterTest { val filter = AdminAuthFilter() filter.init(mockFilterConfig) var proceeded = false - assertThat { + assertFailure { filter.doFilter(mockRequest, mockResponse) { _, _ -> proceeded = true } - }.isFailure().hasMessage("Invalid credentials") + }.hasMessage("Invalid credentials") assertThat(proceeded).isFalse() EasyMock.verify(mockResponse) } @@ -128,11 +130,11 @@ class AdminAuthFilterTest { val filter = AdminAuthFilter() filter.init(mockFilterConfig) var proceeded = false - assertThat { + assertFailure { filter.doFilter(mockRequest, mockResponse) { _, _ -> proceeded = true } - }.isFailure().hasMessage("Invalid credentials") + }.hasMessage("Invalid credentials") assertThat(proceeded).isFalse() EasyMock.verify(mockResponse) } diff --git a/server/src/test/kotlin/com/trib3/server/filters/CookieTokenAuthFilterTest.kt b/server/src/test/kotlin/com/trib3/server/filters/CookieTokenAuthFilterTest.kt index 27660be66..aff587d17 100644 --- a/server/src/test/kotlin/com/trib3/server/filters/CookieTokenAuthFilterTest.kt +++ b/server/src/test/kotlin/com/trib3/server/filters/CookieTokenAuthFilterTest.kt @@ -1,8 +1,8 @@ package com.trib3.server.filters +import assertk.assertFailure import assertk.assertThat import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isSuccess import assertk.assertions.messageContains @@ -47,9 +47,11 @@ class CookieTokenAuthFilterTest { val captureContext = EasyMock.newCapture() EasyMock.expect(mockContext.setSecurityContext(EasyMock.capture(captureContext))) EasyMock.replay(mockContext) - assertThat { - filter.filter(mockContext) - }.isSuccess() + assertThat( + runCatching { + filter.filter(mockContext) + }, + ).isSuccess() assertThat(captureContext.value.userPrincipal).isInstanceOf(Session::class) assertThat((captureContext.value.userPrincipal as Session).email).isEqualTo("blah@blee.com") EasyMock.verify(mockContext) @@ -62,9 +64,9 @@ class CookieTokenAuthFilterTest { mapOf("cookieName" to Cookie("cookieName", "badvalue")), ) EasyMock.replay(mockContext) - assertThat { + assertFailure { filter.filter(mockContext) - }.isFailure().isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") + }.isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") EasyMock.verify(mockContext) } @@ -75,9 +77,9 @@ class CookieTokenAuthFilterTest { mapOf("wrongCookieName" to Cookie("wrongCookieName", "value")), ) EasyMock.replay(mockContext) - assertThat { + assertFailure { filter.filter(mockContext) - }.isFailure().isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") + }.isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") EasyMock.verify(mockContext) } @@ -86,9 +88,9 @@ class CookieTokenAuthFilterTest { val mockContext = LeakyMock.niceMock() EasyMock.expect(mockContext.cookies).andReturn(mapOf()) EasyMock.replay(mockContext) - assertThat { + assertFailure { filter.filter(mockContext) - }.isFailure().isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") + }.isInstanceOf(WebApplicationException::class).messageContains("401 Unauthorized") EasyMock.verify(mockContext) } } diff --git a/testing/pom.xml b/testing/pom.xml index 2c4509f7f..47968710c 100644 --- a/testing/pom.xml +++ b/testing/pom.xml @@ -8,7 +8,7 @@ com.trib3 leakycauldron - 2.1-SNAPSHOT + 2.2-SNAPSHOT ../pom.xml diff --git a/testing/src/test/kotlin/com/trib3/testing/LeakyMockTest.kt b/testing/src/test/kotlin/com/trib3/testing/LeakyMockTest.kt index a0f8e9bbd..f612443e8 100644 --- a/testing/src/test/kotlin/com/trib3/testing/LeakyMockTest.kt +++ b/testing/src/test/kotlin/com/trib3/testing/LeakyMockTest.kt @@ -1,9 +1,9 @@ package com.trib3.testing +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isNotNull import assertk.assertions.isNull import assertk.assertions.isSuccess @@ -110,9 +110,9 @@ class LeakyMockTest { EasyMock.replay(mock, mockedThing) assertThat(mock.getThing()).isEqualTo(RealThing(1)) assertThat(mock.manipulateThing(mockedThing)).isEqualTo(mockedThing) - assertThat { mock.processThing(mockedThing) }.isSuccess() - assertThat { mock.processThing(RealThing(2)) }.isSuccess() - assertThat { mock.processThing(RealThing(3)) }.isSuccess() + assertThat(runCatching { mock.processThing(mockedThing) }).isSuccess() + assertThat(runCatching { mock.processThing(RealThing(2)) }).isSuccess() + assertThat(runCatching { mock.processThing(RealThing(3)) }).isSuccess() EasyMock.verify(mock, mockedThing) } @@ -144,21 +144,21 @@ class LeakyMockTest { @Test fun showNullProblems() { val mock = LeakyMock.niceMock("namedNiceMock", TestClass::class.java) - assertThat { + assertFailure { EasyMock.expect(mock.manipulateThing(EasyMock.anyObject())) - }.isFailure().message().isNotNull().contains("anyObject() must not be null") - assertThat { + }.message().isNotNull().contains("anyObject() must not be null") + assertFailure { EasyMock.expect(mock.manipulateString(EasyMock.anyString())) - }.isFailure().message().isNotNull().contains("anyString() must not be null") + }.message().isNotNull().contains("anyString() must not be null") } @Test fun testInvalidAndOr() { - assertThat { + assertFailure { LeakyMock.and() - }.isFailure().message().isNotNull().contains("at least one argument") - assertThat { + }.message().isNotNull().contains("at least one argument") + assertFailure { LeakyMock.or() - }.isFailure().message().isNotNull().contains("at least one argument") + }.message().isNotNull().contains("at least one argument") } } diff --git a/testing/src/test/kotlin/com/trib3/testing/db/DAOTestBaseTest.kt b/testing/src/test/kotlin/com/trib3/testing/db/DAOTestBaseTest.kt index 151c3acf6..eb40ee0dd 100644 --- a/testing/src/test/kotlin/com/trib3/testing/db/DAOTestBaseTest.kt +++ b/testing/src/test/kotlin/com/trib3/testing/db/DAOTestBaseTest.kt @@ -1,11 +1,11 @@ package com.trib3.testing.db import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.hasSize import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isInstanceOf import assertk.assertions.isSameAs @@ -52,18 +52,18 @@ class DAOTestBaseTest : DAOTestBase() { override fun tearDown() { super.tearDown() // ensure db is no longer usable via jooq - assertThat { + assertFailure { ctx.select(DSL.field("table_name")) .from("information_schema.tables") .where("table_name='tables'").fetch() - }.isFailure().isInstanceOf(DataAccessException::class) + }.isInstanceOf(DataAccessException::class) // ensure db is no longer usable via jdbc var reached = false - assertThat { + assertFailure { dataSource.connection.use { reached = true } - }.isFailure().isInstanceOf(SQLException::class) + }.isInstanceOf(SQLException::class) assertThat(reached).isFalse() } } diff --git a/testing/src/test/kotlin/com/trib3/testing/server/JettyWebTestContainerFactoryTest.kt b/testing/src/test/kotlin/com/trib3/testing/server/JettyWebTestContainerFactoryTest.kt index 75b528acf..d4ef2c148 100644 --- a/testing/src/test/kotlin/com/trib3/testing/server/JettyWebTestContainerFactoryTest.kt +++ b/testing/src/test/kotlin/com/trib3/testing/server/JettyWebTestContainerFactoryTest.kt @@ -1,9 +1,9 @@ package com.trib3.testing.server import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.messageContains import org.eclipse.jetty.server.NetworkConnector import org.glassfish.jersey.server.ResourceConfig @@ -21,12 +21,12 @@ class JettyWebTestContainerFactoryTest { @Test fun testNoUriPath() { - assertThat { + assertFailure { factory.create( URI("http", "test.com", "", ""), deploymentContext, ) - }.isFailure().all { + }.all { messageContains("URI path") messageContains("must be present") } @@ -34,12 +34,12 @@ class JettyWebTestContainerFactoryTest { @Test fun testNoSlashInUriPath() { - assertThat { + assertFailure { factory.create( URI(null, null, "zzz", ""), deploymentContext, ) - }.isFailure().all { + }.all { messageContains("URI path") messageContains("must start with a '/'") } @@ -47,12 +47,12 @@ class JettyWebTestContainerFactoryTest { @Test fun testWrongUriScheme() { - assertThat { + assertFailure { factory.create( URI("https", "test.com", "/zzz", ""), deploymentContext, ) - }.isFailure().all { + }.all { messageContains("URI scheme") messageContains("must be http") }