From 58995b727c19973273c2674bc09f48087d2a4aff Mon Sep 17 00:00:00 2001 From: Numichi Date: Wed, 16 Feb 2022 21:19:26 +0100 Subject: [PATCH] v2.0.0-RC0 --- gradle.properties | 2 +- .../github/numichi/reactive/logger/ICore.kt | 31 +++++ .../reactive/logger/abstracts/ICore.kt | 29 ----- .../{abstracts => coroutine}/ACoroutine.kt | 6 +- .../logger/coroutine/CoroutineKLogger.kt | 1 - .../logger/coroutine/CoroutineLogger.kt | 1 - .../logger/coroutine/ICoroutineCore.kt | 8 +- .../reactive/logger/coroutine/readMDC.kt | 41 +++++-- .../exception/ContextNotExistException.kt | 2 +- .../{abstracts => reactor}/AReactive.kt | 3 +- .../reactive/logger/reactor/IReactorCore.kt | 4 +- .../logger/reactor/ReactiveKLogger.kt | 1 - .../reactive/logger/reactor/ReactiveLogger.kt | 1 - .../logger/coroutine/CoroutineOtherTest.kt | 109 +++++++++++++++++- .../logger/coroutine/MDCContextTest.kt | 73 ++++++++---- .../logger/reactor/java/ReactorJavaTest.java | 31 +++++ 16 files changed, 266 insertions(+), 77 deletions(-) create mode 100644 src/main/java/io/github/numichi/reactive/logger/ICore.kt delete mode 100644 src/main/java/io/github/numichi/reactive/logger/abstracts/ICore.kt rename src/main/java/io/github/numichi/reactive/logger/{abstracts => coroutine}/ACoroutine.kt (84%) rename src/main/java/io/github/numichi/reactive/logger/{abstracts => reactor}/AReactive.kt (90%) create mode 100644 src/test/java/io/github/numichi/reactive/logger/reactor/java/ReactorJavaTest.java diff --git a/gradle.properties b/gradle.properties index 17e7780..ca6b82f 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -version=2.0.0-ALPHA +version=2.0.0-RC0 group=io.github.numichi developerId=numichi developerName=Donát Csongor diff --git a/src/main/java/io/github/numichi/reactive/logger/ICore.kt b/src/main/java/io/github/numichi/reactive/logger/ICore.kt new file mode 100644 index 0000000..6dc5778 --- /dev/null +++ b/src/main/java/io/github/numichi/reactive/logger/ICore.kt @@ -0,0 +1,31 @@ +package io.github.numichi.reactive.logger + +import io.github.numichi.reactive.logger.coroutine.readMDCResult +import io.github.numichi.reactive.logger.exception.ContextNotExistException +import io.github.numichi.reactive.logger.exception.InvalidContextDataException +import io.github.numichi.reactive.logger.reactor.MDCSnapshot +import reactor.core.scheduler.Scheduler +import reactor.util.context.ContextView +import java.util.* + +interface ICore { + val isEnableError: Boolean + val mdcContextKey: String + val scheduler: Scheduler + val name: String + + fun readMDC(context: ContextView): Optional> { + return Optional.ofNullable(readMDCResult(context, mdcContextKey).getOrNull()) + } + + @Throws(ContextNotExistException::class, InvalidContextDataException::class) + fun takeMDCSnapshot(context: ContextView): MDCSnapshot { + val result = readMDCResult(context, mdcContextKey) + + return when { + result.isSuccess -> MDCSnapshot.of(result.getOrNull()) + result.isFailure && !isEnableError -> MDCSnapshot.empty() + else -> throw result.exceptionOrNull()!! + } + } +} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/abstracts/ICore.kt b/src/main/java/io/github/numichi/reactive/logger/abstracts/ICore.kt deleted file mode 100644 index c5bfffb..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/abstracts/ICore.kt +++ /dev/null @@ -1,29 +0,0 @@ -package io.github.numichi.reactive.logger.abstracts - -import io.github.numichi.reactive.logger.exception.ContextNotExistException -import io.github.numichi.reactive.logger.reactor.MDCSnapshot -import reactor.core.scheduler.Scheduler -import reactor.util.context.Context -import java.util.* - -interface ICore { - val isEnableError: Boolean - val mdcContextKey: String - val scheduler: Scheduler - val name: String - - fun readMDC(context: Context): Optional> { - return context.getOrEmpty(mdcContextKey) - } - - @Throws(ContextNotExistException::class) - fun takeMDCSnapshot(context: Context): MDCSnapshot { - val optionalSnapshot = readMDC(context).map { MDCSnapshot.of(it) } - - return if (isEnableError) { - optionalSnapshot.orElseThrow { ContextNotExistException("\"$mdcContextKey\" context not found") } - } else { - optionalSnapshot.orElseGet { MDCSnapshot.empty() } - } - } -} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/abstracts/ACoroutine.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/ACoroutine.kt similarity index 84% rename from src/main/java/io/github/numichi/reactive/logger/abstracts/ACoroutine.kt rename to src/main/java/io/github/numichi/reactive/logger/coroutine/ACoroutine.kt index 96c8a9a..0ff63d1 100644 --- a/src/main/java/io/github/numichi/reactive/logger/abstracts/ACoroutine.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/ACoroutine.kt @@ -1,9 +1,5 @@ -package io.github.numichi.reactive.logger.abstracts +package io.github.numichi.reactive.logger.coroutine -import io.github.numichi.reactive.logger.coroutine.CCElement -import io.github.numichi.reactive.logger.coroutine.CCKey -import io.github.numichi.reactive.logger.coroutine.CCResolveFn -import io.github.numichi.reactive.logger.coroutine.ICoroutineCore import io.github.numichi.reactive.logger.reactor.IReactorLogger import org.slf4j.Logger import reactor.core.scheduler.Scheduler diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineKLogger.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineKLogger.kt index e2e9a94..ffcc450 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineKLogger.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineKLogger.kt @@ -1,7 +1,6 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.DefaultValues -import io.github.numichi.reactive.logger.abstracts.ACoroutine import io.github.numichi.reactive.logger.reactor.IReactorKLogger import io.github.numichi.reactive.logger.reactor.ReactiveKLogger import io.github.numichi.reactive.logger.reactor.ReactiveLogger diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineLogger.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineLogger.kt index 25b27d1..8250a57 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineLogger.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/CoroutineLogger.kt @@ -1,7 +1,6 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.DefaultValues -import io.github.numichi.reactive.logger.abstracts.ACoroutine import io.github.numichi.reactive.logger.reactor.IReactorLogger import io.github.numichi.reactive.logger.reactor.ReactiveLogger import kotlinx.coroutines.reactor.ReactorContext diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/ICoroutineCore.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/ICoroutineCore.kt index 452918b..ce334c2 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/ICoroutineCore.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/ICoroutineCore.kt @@ -1,13 +1,16 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.abstracts.ICore +import io.github.numichi.reactive.logger.ICore +import io.github.numichi.reactive.logger.exception.ContextNotExistException +import io.github.numichi.reactive.logger.exception.InvalidContextDataException import io.github.numichi.reactive.logger.reactor.IReactorLogger import kotlinx.coroutines.reactor.ReactorContext import kotlinx.coroutines.reactor.awaitSingle import kotlinx.coroutines.reactor.awaitSingleOrNull import reactor.core.publisher.Mono import reactor.util.context.Context +import reactor.util.context.ContextView import kotlin.coroutines.coroutineContext interface ICoroutineCore : ICore { @@ -18,7 +21,8 @@ interface ICoroutineCore : ICore { override val name: String get() = reactorLogger.name - suspend fun snapshot(context: Context? = null): MDC? { + @Throws(ContextNotExistException::class, InvalidContextDataException::class) + suspend fun snapshot(context: ContextView? = null): MDC? { val ctx = context ?: coroutineContext[ReactorContext]?.context return ctx?.let { reactorLogger.snapshot(it).awaitSingleOrNull() } } diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/readMDC.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/readMDC.kt index c725a92..34a7b81 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/readMDC.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/readMDC.kt @@ -2,22 +2,27 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.DefaultValues import io.github.numichi.reactive.logger.MDC +import io.github.numichi.reactive.logger.exception.ContextNotExistException import io.github.numichi.reactive.logger.exception.InvalidContextDataException import reactor.util.context.ContextView -suspend fun readMDC(): MDC { - return readMDC(DefaultValues.getInstance().defaultReactorContextMdcKey) +@Throws(ContextNotExistException::class, InvalidContextDataException::class) +suspend fun readMdc(): MDC { + return readMdc(DefaultValues.getInstance().defaultReactorContextMdcKey) } -suspend fun readMDC(mdcContextKey: String): MDC { - return readMDC(rectorContext(), mdcContextKey) +@Throws(ContextNotExistException::class, InvalidContextDataException::class) +suspend fun readMdc(mdcContextKey: String): MDC { + return readMdc(rectorContext(), mdcContextKey) } -fun readMDC(contextView: ContextView?): MDC { - return readMDC(contextView, DefaultValues.getInstance().defaultReactorContextMdcKey) +@Throws(ContextNotExistException::class, InvalidContextDataException::class) +fun readMdc(contextView: ContextView?): MDC { + return readMdc(contextView, DefaultValues.getInstance().defaultReactorContextMdcKey) } -fun readMDC(contextView: ContextView?, mdcContextKey: String): MDC { +@Throws(ContextNotExistException::class, InvalidContextDataException::class) +fun readMdc(contextView: ContextView?, mdcContextKey: String): MDC { requireNotNull(contextView) { "contentView must not be null" } val mdc = MDC(mdcContextKey) @@ -25,9 +30,31 @@ fun readMDC(contextView: ContextView?, mdcContextKey: String): MDC { try { val map: Map = contextView.get(mdcContextKey) mdc.putAll(map) + } catch (noSuchException: NoSuchElementException) { + throw ContextNotExistException("\"$mdcContextKey\" context not found", noSuchException) } catch (exception: Exception) { throw InvalidContextDataException(exception) } return mdc +} + +suspend fun readMdcOrNull(): MDC? { + return readMdcOrNull(DefaultValues.getInstance().defaultReactorContextMdcKey) +} + +suspend fun readMdcOrNull(mdcContextKey: String): MDC? { + return readMdcOrNull(rectorContext(), mdcContextKey) +} + +fun readMdcOrNull(contextView: ContextView?): MDC? { + return readMdcOrNull(contextView, DefaultValues.getInstance().defaultReactorContextMdcKey) +} + +fun readMdcOrNull(contextView: ContextView?, mdcContextKey: String): MDC? { + return readMDCResult(contextView, mdcContextKey).getOrNull() +} + +fun readMDCResult(contextView: ContextView?, mdcContextKey: String): Result { + return runCatching { readMdc(contextView, mdcContextKey) } } \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/exception/ContextNotExistException.kt b/src/main/java/io/github/numichi/reactive/logger/exception/ContextNotExistException.kt index 30d8ab6..861da6a 100644 --- a/src/main/java/io/github/numichi/reactive/logger/exception/ContextNotExistException.kt +++ b/src/main/java/io/github/numichi/reactive/logger/exception/ContextNotExistException.kt @@ -1,3 +1,3 @@ package io.github.numichi.reactive.logger.exception; -class ContextNotExistException(message: String) : RuntimeException(message) +class ContextNotExistException(message: String, throwable: Throwable) : RuntimeException(message, throwable) diff --git a/src/main/java/io/github/numichi/reactive/logger/abstracts/AReactive.kt b/src/main/java/io/github/numichi/reactive/logger/reactor/AReactive.kt similarity index 90% rename from src/main/java/io/github/numichi/reactive/logger/abstracts/AReactive.kt rename to src/main/java/io/github/numichi/reactive/logger/reactor/AReactive.kt index c18d45b..2502a22 100644 --- a/src/main/java/io/github/numichi/reactive/logger/abstracts/AReactive.kt +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/AReactive.kt @@ -1,6 +1,5 @@ -package io.github.numichi.reactive.logger.abstracts +package io.github.numichi.reactive.logger.reactor -import io.github.numichi.reactive.logger.reactor.IReactorCore import org.slf4j.Logger import reactor.core.scheduler.Scheduler diff --git a/src/main/java/io/github/numichi/reactive/logger/reactor/IReactorCore.kt b/src/main/java/io/github/numichi/reactive/logger/reactor/IReactorCore.kt index c3e3dc1..7dfae24 100644 --- a/src/main/java/io/github/numichi/reactive/logger/reactor/IReactorCore.kt +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/IReactorCore.kt @@ -1,7 +1,7 @@ package io.github.numichi.reactive.logger.reactor import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.abstracts.ICore +import io.github.numichi.reactive.logger.ICore import io.github.numichi.reactive.logger.exception.ContextNotExistException import org.slf4j.Logger import reactor.core.publisher.Mono @@ -14,7 +14,7 @@ interface IReactorCore : ICore { override val name: String get() = logger.name - fun snapshot(context: Context): Mono { + fun snapshot(context: ContextView): Mono { return try { var mdc: MDC takeMDCSnapshot(context).use { diff --git a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveKLogger.kt b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveKLogger.kt index 4d9c7b0..bb05a45 100644 --- a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveKLogger.kt +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveKLogger.kt @@ -1,7 +1,6 @@ package io.github.numichi.reactive.logger.reactor import io.github.numichi.reactive.logger.DefaultValues -import io.github.numichi.reactive.logger.abstracts.AReactive import mu.KLogger import mu.KotlinLogging import org.slf4j.LoggerFactory diff --git a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.kt b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.kt index 4e13d80..4256410 100644 --- a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.kt +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.kt @@ -1,7 +1,6 @@ package io.github.numichi.reactive.logger.reactor import io.github.numichi.reactive.logger.DefaultValues -import io.github.numichi.reactive.logger.abstracts.AReactive import org.slf4j.Logger import org.slf4j.LoggerFactory import reactor.core.scheduler.Scheduler diff --git a/src/test/java/io/github/numichi/reactive/logger/coroutine/CoroutineOtherTest.kt b/src/test/java/io/github/numichi/reactive/logger/coroutine/CoroutineOtherTest.kt index 98a7ef9..57c1ca3 100644 --- a/src/test/java/io/github/numichi/reactive/logger/coroutine/CoroutineOtherTest.kt +++ b/src/test/java/io/github/numichi/reactive/logger/coroutine/CoroutineOtherTest.kt @@ -1,22 +1,30 @@ package io.github.numichi.reactive.logger.coroutine +import io.github.numichi.reactive.logger.MDC +import io.github.numichi.reactive.logger.exception.ContextNotExistException +import io.github.numichi.reactive.logger.exception.InvalidContextDataException +import io.github.numichi.reactive.logger.reactor.MDCContext +import io.github.numichi.reactive.logger.reactor.MDCSnapshot import io.mockk.mockk import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.reactor.ReactorContext +import kotlinx.coroutines.reactor.mono import kotlinx.coroutines.test.runTest import mu.KLogger import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertSame import org.junit.jupiter.api.Test import org.slf4j.Logger +import reactor.core.publisher.Mono import reactor.core.scheduler.Schedulers +import reactor.test.StepVerifier +import kotlin.math.log @ExperimentalCoroutinesApi internal class CoroutineOtherTest { - @Test - fun `test11`() = runTest { + fun `configuration with chain`() = runTest { val mockKLogger: KLogger = mockk(relaxed = true) val loggerK = CoroutineKLogger.reactorBuilder() .withContextKey(ReactorContext) @@ -49,7 +57,7 @@ internal class CoroutineOtherTest { } @Test - fun `test12`() = runTest { + fun `configuration with attributes`() = runTest { val mockKLogger: KLogger = mockk(relaxed = true) val kBuilder = CoroutineKLogger.reactorBuilder() kBuilder.contextKey = ReactorContext @@ -92,4 +100,99 @@ internal class CoroutineOtherTest { assertSame(Schedulers.boundedElastic(), loggerL.scheduler) assertEquals(mockLogger, loggerL.logger) } + + @Test + fun `should get MDC data from snapshot (KLogger)`() { + val logger = CoroutineKLogger.reactorBuilder() + .withLogger(mockk(relaxed = true)) + .build() + + val x = mono { logger.snapshot()?.get("foo") } + .contextWrite { + val mdc = MDC() + mdc["foo"] = "bar" + MDCContext.put(it, mdc) + } + + StepVerifier.create(x) + .expectNext("bar") + .verifyComplete() + + } + + @Test + fun `should get MDC data from snapshot (Logger)`() { + val logger = CoroutineLogger.reactorBuilder() + .withLogger(mockk(relaxed = true)) + .build() + + val x = mono { logger.snapshot()?.get("foo") } + .contextWrite { + val mdc = MDC() + mdc["foo"] = "bar" + MDCContext.put(it, mdc) + } + + StepVerifier.create(x) + .expectNext("bar") + .verifyComplete() + + } + + @Test + fun `snapshot and direct export matching`() { + val logger = CoroutineLogger.reactorBuilder() + .withLogger(mockk(relaxed = true)) + .build() + + val mdcContextKey = logger.mdcContextKey; + + val mdc = MDC() + mdc["foo"] = "bar" + + val x = mono { logger.snapshot() } + .contextWrite { MDCContext.put(it, mdc) } + + val y = Mono.deferContextual { context -> + var mdcData: MDC? = null + try { + val temp: MDCSnapshot? = context.getOrEmpty>(mdcContextKey) + .map { MDCSnapshot.of(it) } + .orElse(null) + + temp?.use { + mdcData = MDC(mdcContextKey, it.copyOfContextMap) + } + + return@deferContextual Mono.justOrEmpty(mdcData) + } catch (exception: Exception) { + return@deferContextual Mono.error(exception) + } + }.contextWrite { MDCContext.put(it, mdc) } + + StepVerifier.create(Mono.zip(x, y)) + .expectNextMatches { it.t1 == it.t2 } + .verifyComplete() + } + + @Test + fun `should throw exception from snapshot`() { + val logger = CoroutineLogger.reactorBuilder() + .withEnableError(true) + .withLogger(mockk(relaxed = true)) + .build() + + val contextNotExistException = mono { logger.snapshot() } + + StepVerifier.create(contextNotExistException) + .expectError(ContextNotExistException::class.java) + .verify() + + val invalidContextDataException = mono { logger.snapshot() } + .contextWrite { it.put(logger.mdcContextKey, 10) } + + StepVerifier.create(invalidContextDataException) + .expectError(InvalidContextDataException::class.java) + .verify() + } } \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/coroutine/MDCContextTest.kt b/src/test/java/io/github/numichi/reactive/logger/coroutine/MDCContextTest.kt index 5ba6e80..8e1b1b1 100644 --- a/src/test/java/io/github/numichi/reactive/logger/coroutine/MDCContextTest.kt +++ b/src/test/java/io/github/numichi/reactive/logger/coroutine/MDCContextTest.kt @@ -2,6 +2,7 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.DefaultValues import io.github.numichi.reactive.logger.MDC +import io.github.numichi.reactive.logger.exception.ContextNotExistException import io.github.numichi.reactive.logger.exception.InvalidContextDataException import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.reactor.ReactorContext @@ -9,6 +10,7 @@ import kotlinx.coroutines.reactor.asCoroutineContext import kotlinx.coroutines.test.runTest import kotlinx.coroutines.withContext import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import reactor.util.context.Context @@ -46,18 +48,18 @@ internal class MDCContextTest { mdc["mdcKey"] = "mdcValue" withMDCContext(mdc) { - val result = readMDC() + val result = readMdc() assertEquals(mdc, result) } withMDCContext(mdc) { - val result = readMDC(coroutineContext[ReactorContext]?.context) + val result = readMdc(coroutineContext[ReactorContext]?.context) assertEquals(mdc, result) } withMDCContext(Context.of(mutableMapOf("1" to "2")), mdc) { val size = coroutineContext[ReactorContext]?.context?.size() - val result = readMDC(coroutineContext[ReactorContext]?.context) + val result = readMdc(coroutineContext[ReactorContext]?.context) assertEquals(mdc, result) assertEquals(2, size) } @@ -69,7 +71,7 @@ internal class MDCContextTest { mdcMap["mdcKey"] = "mdcValue" withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to mdcMap)).asCoroutineContext()) { - val result = readMDC(coroutineContext[ReactorContext]?.context) + val result = readMdc(coroutineContext[ReactorContext]?.context) assertEquals(mdcMap, result) assertEquals(mdcMap, result) } @@ -81,7 +83,7 @@ internal class MDCContextTest { mdc2["mdcKey"] = "mdcValue" withMDCContext(mdc2) { - val result = readMDC(ANOTHER_CONTEXT_KEY) + val result = readMdc(ANOTHER_CONTEXT_KEY) assertEquals(mdc2, result) } } @@ -95,11 +97,11 @@ internal class MDCContextTest { mdc2["mdcKey"] = "mdcValue" withMDCContext(mdc1, mdc2) { - val result1 = readMDC(coroutineContext[ReactorContext]?.context) - val result2 = readMDC(coroutineContext[ReactorContext]?.context, DefaultValues.getInstance().defaultReactorContextMdcKey) - val result3 = readMDC(DefaultValues.getInstance().defaultReactorContextMdcKey) - val result4 = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) - val result5 = readMDC(ANOTHER_CONTEXT_KEY) + val result1 = readMdc(coroutineContext[ReactorContext]?.context) + val result2 = readMdc(coroutineContext[ReactorContext]?.context, DefaultValues.getInstance().defaultReactorContextMdcKey) + val result3 = readMdc(DefaultValues.getInstance().defaultReactorContextMdcKey) + val result4 = readMdc(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) + val result5 = readMdc(ANOTHER_CONTEXT_KEY) assertEquals(mdc1, result1) assertEquals(mdc1, result2) @@ -115,12 +117,18 @@ internal class MDCContextTest { mdcMap["mdcKey"] = "mdcValue" withMDCContext(MDC(mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context) - assertEquals(mdcMap, result) + val result1 = readMdc(coroutineContext[ReactorContext]?.context) + val result2 = readMdc() + val result3 = readMdcOrNull(coroutineContext[ReactorContext]?.context) + val result4 = readMdcOrNull() + assertEquals(mdcMap, result1) + assertEquals(mdcMap, result2) + assertEquals(mdcMap, result3) + assertEquals(mdcMap, result4) } withMDCContext(MDC(ANOTHER_CONTEXT_KEY, mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) + val result = readMdc(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) assertEquals(mdcMap, result) } } @@ -131,31 +139,54 @@ internal class MDCContextTest { mdcMap["mdcKey"] = "mdcValue" withMDCContext(MDC(mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context) - assertEquals(mdcMap, result) + val result1 = readMdc(coroutineContext[ReactorContext]?.context) + val result2 = readMdcOrNull(coroutineContext[ReactorContext]?.context) + assertEquals(mdcMap, result1) + assertEquals(mdcMap, result2) } withMDCContext(MDC(ANOTHER_CONTEXT_KEY, mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) - assertEquals(mdcMap, result) + val result1 = readMdc(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) + val result2 = readMdcOrNull(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) + assertEquals(mdcMap, result1) + assertEquals(mdcMap, result2) + } + } + + @Test + fun `should get null if context data is invalid`() = runTest { + withContext(Context.empty().asCoroutineContext()) { + assertNull(readMdcOrNull()) + } + + assertNull(readMdcOrNull(null)) + assertNull(readMdcOrNull(null, "")) + } + + @Test + fun `should throw ContextNotExistException if context data is invalid`() = runTest { + withContext(Context.empty().asCoroutineContext()) { + assertThrows { readMdc() } } } @Test fun `should throw InvalidContextDataException if context data is invalid`() = runTest { withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to 10)).asCoroutineContext()) { - assertThrows { readMDC() } + assertThrows { readMdc() } + assertNull(readMdcOrNull()) } withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to "any")).asCoroutineContext()) { - assertThrows { readMDC() } + assertThrows { readMdc() } + assertNull(readMdcOrNull()) } } @Test fun `should throw IllegalArgumentException if any parameter is NULL`() = runTest { assertThrows { withMDCContext(null, MDC()) {} } - assertThrows { readMDC(null) } - assertThrows { readMDC(null, "any-key") } + assertThrows { readMdc(null) } + assertThrows { readMdc(null, "any-key") } } } \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/reactor/java/ReactorJavaTest.java b/src/test/java/io/github/numichi/reactive/logger/reactor/java/ReactorJavaTest.java new file mode 100644 index 0000000..321bc89 --- /dev/null +++ b/src/test/java/io/github/numichi/reactive/logger/reactor/java/ReactorJavaTest.java @@ -0,0 +1,31 @@ +package io.github.numichi.reactive.logger.reactor.java; + +import io.github.numichi.reactive.logger.MDC; +import io.github.numichi.reactive.logger.reactor.IReactorLogger; +import io.github.numichi.reactive.logger.reactor.MDCContext; +import io.github.numichi.reactive.logger.reactor.ReactiveLogger; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import reactor.core.publisher.Mono; +import reactor.test.StepVerifier; +import reactor.util.context.Context; + +import static org.mockito.Mockito.mock; + +public class ReactorJavaTest { + + @Test + public void javaBaseTest1() { + IReactorLogger logger = ReactiveLogger.builder().withLogger(mock(Logger.class)).build(); + + MDC model = new MDC(); + model.put("bar", "baz"); + + Mono mono = Mono.deferContextual(logger::snapshot) + .contextWrite((Context contextView) -> MDCContext.put(contextView, model)); + + StepVerifier.create(mono) + .expectNextMatches((MDC mdc) -> mdc.equals(model)) + .verifyComplete(); + } +}