From 2edb46077cc20edcca1b41326dc2eaaa073f4529 Mon Sep 17 00:00:00 2001 From: Numichi Date: Fri, 28 Jan 2022 16:51:10 +0100 Subject: [PATCH] remove old packages and can be configuration default values --- gradle.properties | 3 +- .../reactive/logger/DefaultValues.java | 84 +++ .../github/numichi/reactive/logger/MDC.java | 4 +- .../numichi/reactive/logger/Values.java | 11 - .../logger/coroutine/ReactiveLogger.kt | 6 +- .../reactive/logger/coroutine/readMDC.kt | 6 +- .../logger/coroutine/withMDCContext.kt | 2 +- .../AlreadyConfigurationException.java | 7 + .../reactive/logger/java/MDCContext.java | 81 --- .../reactive/logger/java/MDCSnapshot.java | 40 -- .../reactive/logger/java/ReactiveLogger.java | 361 ----------- .../reactive/logger/kotlin/ReactiveLogger.kt | 332 ---------- .../numichi/reactive/logger/kotlin/helper.kt | 32 - .../numichi/reactive/logger/kotlin/putMDC.kt | 12 - .../numichi/reactive/logger/kotlin/readMDC.kt | 49 -- .../reactive/logger/kotlin/withMDCContext.kt | 29 - .../reactive/logger/reactor/MDCContext.java | 6 +- .../logger/reactor/ReactiveLogger.java | 6 +- .../logger/coroutine/MDCContextTest.kt | 16 +- .../logger/coroutine/ReactiveLoggerTest.kt | 7 +- .../reactive/logger/java/MDCContextTest.java | 181 ------ .../reactive/logger/java/MDCSnapshotTest.java | 42 -- .../logger/java/ReactiveLoggerTest.java | 552 ----------------- .../reactive/logger/kotlin/MDCContextTest.kt | 164 ----- .../logger/kotlin/ReactiveLoggerTest.kt | 584 ------------------ .../logger/reactor/MDCContextTest.java | 9 +- .../logger/reactor/MDCSnapshotTest.java | 1 - .../logger/reactor/ReactiveLoggerTest.java | 8 +- 28 files changed, 126 insertions(+), 2509 deletions(-) create mode 100644 src/main/java/io/github/numichi/reactive/logger/DefaultValues.java delete mode 100644 src/main/java/io/github/numichi/reactive/logger/Values.java create mode 100644 src/main/java/io/github/numichi/reactive/logger/exception/AlreadyConfigurationException.java delete mode 100644 src/main/java/io/github/numichi/reactive/logger/java/MDCContext.java delete mode 100644 src/main/java/io/github/numichi/reactive/logger/java/MDCSnapshot.java delete mode 100644 src/main/java/io/github/numichi/reactive/logger/java/ReactiveLogger.java delete mode 100644 src/main/java/io/github/numichi/reactive/logger/kotlin/ReactiveLogger.kt delete mode 100644 src/main/java/io/github/numichi/reactive/logger/kotlin/helper.kt delete mode 100644 src/main/java/io/github/numichi/reactive/logger/kotlin/putMDC.kt delete mode 100644 src/main/java/io/github/numichi/reactive/logger/kotlin/readMDC.kt delete mode 100644 src/main/java/io/github/numichi/reactive/logger/kotlin/withMDCContext.kt delete mode 100644 src/test/java/io/github/numichi/reactive/logger/java/MDCContextTest.java delete mode 100644 src/test/java/io/github/numichi/reactive/logger/java/MDCSnapshotTest.java delete mode 100644 src/test/java/io/github/numichi/reactive/logger/java/ReactiveLoggerTest.java delete mode 100644 src/test/java/io/github/numichi/reactive/logger/kotlin/MDCContextTest.kt delete mode 100644 src/test/java/io/github/numichi/reactive/logger/kotlin/ReactiveLoggerTest.kt diff --git a/gradle.properties b/gradle.properties index ff4b802..78103ef 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,5 +1,4 @@ -kotlin.code.style=official -version=1.1.1 +version=1.2.0 group=io.github.numichi developerId=numichi developerName=Donát Csongor diff --git a/src/main/java/io/github/numichi/reactive/logger/DefaultValues.java b/src/main/java/io/github/numichi/reactive/logger/DefaultValues.java new file mode 100644 index 0000000..7ae7976 --- /dev/null +++ b/src/main/java/io/github/numichi/reactive/logger/DefaultValues.java @@ -0,0 +1,84 @@ +package io.github.numichi.reactive.logger; + +import io.github.numichi.reactive.logger.annotations.JacocoSkipGeneratedReport; +import io.github.numichi.reactive.logger.exception.AlreadyConfigurationException; +import reactor.core.scheduler.Scheduler; +import reactor.core.scheduler.Schedulers; + +@JacocoSkipGeneratedReport +public class DefaultValues { + private static final String DEFAULT_REACTOR_CONTEXT_MDC_KEY = "EFAULT_REACTOR_CONTEXT_MDC_KEY"; + private static final Scheduler DEFAULT_SCHEDULER = Schedulers.boundedElastic(); + private static DefaultValues instance = null; + private final String defaultReactorContextMdcKey; + private final Scheduler defaultScheduler; + + private DefaultValues() { + this(DEFAULT_REACTOR_CONTEXT_MDC_KEY, DEFAULT_SCHEDULER); + } + + private DefaultValues(Scheduler defaultScheduler) { + this(DEFAULT_REACTOR_CONTEXT_MDC_KEY, defaultScheduler); + } + + private DefaultValues(String defaultReactorContextMdcKey) { + this(defaultReactorContextMdcKey, DEFAULT_SCHEDULER); + } + + private DefaultValues(String defaultReactorContextMdcKey, Scheduler defaultScheduler) { + this.defaultReactorContextMdcKey = defaultReactorContextMdcKey; + this.defaultScheduler = defaultScheduler; + } + + public static DefaultValues getInstance() { + if (instance == null) { + instance = configuration(); + } + + return instance; + } + + public static DefaultValues configuration() throws AlreadyConfigurationException { + if (instance == null) { + instance = new DefaultValues(); + return instance; + } else { + throw new AlreadyConfigurationException(); + } + } + + public static DefaultValues configuration(Scheduler defaultScheduler) throws AlreadyConfigurationException { + if (instance == null) { + instance = new DefaultValues(defaultScheduler); + return instance; + } else { + throw new AlreadyConfigurationException(); + } + } + + public static DefaultValues configuration(String defaultReactorContextMdcKey) throws AlreadyConfigurationException { + if (instance == null) { + instance = new DefaultValues(defaultReactorContextMdcKey); + return instance; + } else { + throw new AlreadyConfigurationException(); + } + } + + public static DefaultValues configuration(String defaultReactorContextMdcKey, Scheduler defaultScheduler) throws AlreadyConfigurationException { + if (instance == null) { + instance = new DefaultValues(defaultReactorContextMdcKey, defaultScheduler); + return instance; + } else { + throw new AlreadyConfigurationException(); + } + } + + public String getDefaultReactorContextMdcKey() { + return defaultReactorContextMdcKey; + } + + public Scheduler getDefaultScheduler() { + return defaultScheduler; + } +} diff --git a/src/main/java/io/github/numichi/reactive/logger/MDC.java b/src/main/java/io/github/numichi/reactive/logger/MDC.java index bf39ccb..d21977d 100644 --- a/src/main/java/io/github/numichi/reactive/logger/MDC.java +++ b/src/main/java/io/github/numichi/reactive/logger/MDC.java @@ -19,7 +19,7 @@ public class MDC implements Map { private final String mdcContextKey; public MDC() { - this(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY, new HashMap<>()); + this(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), new HashMap<>()); } public MDC(String mdcContextKey) { @@ -27,7 +27,7 @@ public MDC(String mdcContextKey) { } public MDC(Map mdc) { - this(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc); + this(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc); } public MDC(String mdcContextKey, Map mdc) { diff --git a/src/main/java/io/github/numichi/reactive/logger/Values.java b/src/main/java/io/github/numichi/reactive/logger/Values.java deleted file mode 100644 index f50a532..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/Values.java +++ /dev/null @@ -1,11 +0,0 @@ -package io.github.numichi.reactive.logger; - -import reactor.core.scheduler.Scheduler; -import reactor.core.scheduler.Schedulers; - -public class Values { - private Values() {} - - public static final String DEFAULT_REACTOR_CONTEXT_MDC_KEY = "DEFAULT_REACTOR_CONTEXT_MDC_KEY"; - public static final Scheduler DEFAULT_SCHEDULER = Schedulers.boundedElastic(); -} diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/ReactiveLogger.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/ReactiveLogger.kt index db5b40a..95bda6a 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/ReactiveLogger.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/ReactiveLogger.kt @@ -1,7 +1,7 @@ package io.github.numichi.reactive.logger.coroutine import io.github.numichi.reactive.logger.reactor.ReactiveLogger as JReactiveLogger -import io.github.numichi.reactive.logger.Values +import io.github.numichi.reactive.logger.DefaultValues import io.github.numichi.reactive.logger.annotations.JacocoSkipGeneratedReport import io.github.numichi.reactive.logger.MDC import kotlinx.coroutines.reactor.ReactorContext @@ -259,9 +259,9 @@ class ReactiveLogger private constructor( } class Builder(private val contextKey: CoroutineContext.Key) { - private var scheduler = Values.DEFAULT_SCHEDULER + private var scheduler: Scheduler = DefaultValues.getInstance().defaultScheduler private var logger = LoggerFactory.getLogger(ReactiveLogger::class.java) - private var mdcContextKey = Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY + private var mdcContextKey: String = DefaultValues.getInstance().defaultReactorContextMdcKey!! private var contextExtractive: suspend (CoroutineContext.Key) -> Context? private var enableError: Boolean = false 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 624b23a..15e0075 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 @@ -1,12 +1,12 @@ package io.github.numichi.reactive.logger.coroutine -import io.github.numichi.reactive.logger.Values +import io.github.numichi.reactive.logger.DefaultValues import io.github.numichi.reactive.logger.exception.InvalidContextDataException import io.github.numichi.reactive.logger.MDC import reactor.util.context.ContextView suspend fun readMDC(): MDC { - return readMDC(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY) + return readMDC(DefaultValues.getInstance().defaultReactorContextMdcKey) } suspend fun readMDC(mdcContextKey: String): MDC { @@ -14,7 +14,7 @@ suspend fun readMDC(mdcContextKey: String): MDC { } fun readMDC(contextView: ContextView?): MDC { - return readMDC(contextView, Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY) + return readMDC(contextView, DefaultValues.getInstance().defaultReactorContextMdcKey) } fun readMDC(contextView: ContextView?, mdcContextKey: String): MDC { diff --git a/src/main/java/io/github/numichi/reactive/logger/coroutine/withMDCContext.kt b/src/main/java/io/github/numichi/reactive/logger/coroutine/withMDCContext.kt index 6d14efa..526c4c0 100644 --- a/src/main/java/io/github/numichi/reactive/logger/coroutine/withMDCContext.kt +++ b/src/main/java/io/github/numichi/reactive/logger/coroutine/withMDCContext.kt @@ -10,6 +10,6 @@ suspend fun withMDCContext(vararg mdc: MDC, block: suspend CoroutineScope.() } suspend fun withMDCContext(context: Context?, vararg mdc: MDC, block: suspend CoroutineScope.() -> T): T { - requireNotNull(context) { "context must not be null"} + requireNotNull(context) { "context must not be null" } return withContextBlock(context, mdc.iterator(), block) } \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/exception/AlreadyConfigurationException.java b/src/main/java/io/github/numichi/reactive/logger/exception/AlreadyConfigurationException.java new file mode 100644 index 0000000..c2c3794 --- /dev/null +++ b/src/main/java/io/github/numichi/reactive/logger/exception/AlreadyConfigurationException.java @@ -0,0 +1,7 @@ +package io.github.numichi.reactive.logger.exception; + +public class AlreadyConfigurationException extends RuntimeException { + public AlreadyConfigurationException() { + super("DefaultValues have already configurated!"); + } +} diff --git a/src/main/java/io/github/numichi/reactive/logger/java/MDCContext.java b/src/main/java/io/github/numichi/reactive/logger/java/MDCContext.java deleted file mode 100644 index 33a5241..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/java/MDCContext.java +++ /dev/null @@ -1,81 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import io.github.numichi.reactive.logger.exception.InvalidContextDataException; -import io.github.numichi.reactive.logger.MDC; -import io.github.numichi.reactive.logger.Values; -import reactor.core.publisher.Mono; -import reactor.util.annotation.NonNull; -import reactor.util.context.Context; -import reactor.util.context.ContextView; - -import java.util.Map; -import java.util.Objects; - -import static io.github.numichi.reactive.logger.exception.Messages.CTXK_NOT_NULL; -import static io.github.numichi.reactive.logger.exception.Messages.CTXW_NOT_NULL; -import static io.github.numichi.reactive.logger.exception.Messages.MDC_NOT_NULL; - -/** - * Use from: io.github.numichi.reactive.logger.reactor; - */ -@Deprecated -public final class MDCContext { - private MDCContext() { - } - - @NonNull - public static Context put(Context context, MDC... mdc) { - try { - Objects.requireNonNull(context, CTXK_NOT_NULL); - Objects.requireNonNull(mdc, MDC_NOT_NULL); - } catch (NullPointerException exception) { - throw new IllegalArgumentException(exception); - } - - for (MDC m : mdc) { - if (m == null) { - continue; - } - - context = context.put(m.getContextKey(), m.asMap()); - } - - return context; - } - - @NonNull - public static Mono read() { - return read(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY); - } - - @NonNull - public static Mono read(String mdcContextKey) { - return Mono.deferContextual(ctx -> read(ctx, mdcContextKey)); - } - - @NonNull - public static Mono read(ContextView context) { - return read(context, Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY); - } - - @NonNull - public static Mono read(@NonNull ContextView contextView, @NonNull String mdcContextKey) { - try { - Objects.requireNonNull(contextView, CTXW_NOT_NULL); - Objects.requireNonNull(mdcContextKey, CTXK_NOT_NULL); - } catch (NullPointerException exception) { - return Mono.error(new IllegalArgumentException(exception)); - } - - MDC mdc = new MDC(mdcContextKey); - - try { - Map map = contextView.get(mdcContextKey); - mdc.putAll(map); - } catch (Exception exception) { - return Mono.error(new InvalidContextDataException(exception)); - } - - return Mono.just(mdc); - } -} diff --git a/src/main/java/io/github/numichi/reactive/logger/java/MDCSnapshot.java b/src/main/java/io/github/numichi/reactive/logger/java/MDCSnapshot.java deleted file mode 100644 index 7f00cf3..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/java/MDCSnapshot.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import org.slf4j.MDC; -import reactor.util.annotation.NonNull; -import reactor.util.annotation.Nullable; - -import java.util.Map; - -/** - * Use from: io.github.numichi.reactive.logger.reactor; - */ -@Deprecated -public final class MDCSnapshot implements AutoCloseable { - private MDCSnapshot(@Nullable final Map context) { - if (context == null) { - MDC.clear(); - } else { - MDC.setContextMap(context); - } - } - - @NonNull - public static MDCSnapshot of(@Nullable final Map context) { - return new MDCSnapshot(context); - } - - @NonNull - public static MDCSnapshot empty() { - return new MDCSnapshot(null); - } - - public Map getCopyOfContextMap() { - return MDC.getCopyOfContextMap(); - } - - @Override - public void close() { - MDC.clear(); - } -} diff --git a/src/main/java/io/github/numichi/reactive/logger/java/ReactiveLogger.java b/src/main/java/io/github/numichi/reactive/logger/java/ReactiveLogger.java deleted file mode 100644 index 0e6cacf..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/java/ReactiveLogger.java +++ /dev/null @@ -1,361 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import io.github.numichi.reactive.logger.MDC; -import io.github.numichi.reactive.logger.exception.ContextNotExistException; -import io.github.numichi.reactive.logger.Values; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.slf4j.Marker; -import reactor.core.publisher.Mono; -import reactor.core.scheduler.Scheduler; -import reactor.util.annotation.NonNull; -import reactor.util.context.Context; - -import java.util.Map; -import java.util.Objects; -import java.util.Optional; - -import static io.github.numichi.reactive.logger.exception.Messages.CTX_NOT_NULL; - -/** - * Use from: io.github.numichi.reactive.logger.reactor; - */ -@Deprecated -public final class ReactiveLogger { - - private static final Logger DEFAULT_LOGGER = LoggerFactory.getLogger(ReactiveLogger.class); - private final Scheduler scheduler; - private final Logger logger; - private final String mdcContextKey; - private final boolean enableError; - - private ReactiveLogger(@NonNull final Builder builder) { - this.scheduler = builder.scheduler; - this.logger = builder.logger; - this.mdcContextKey = builder.mdcContextKey; - this.enableError = builder.enableError; - } - - @NonNull - public static Builder builder() { - return new Builder(); - } - - public Logger imperative() { - return logger; - } - - public Scheduler scheduler() { - return scheduler; - } - - public String mdcContextKey() { - return mdcContextKey; - } - - public boolean isEnableError() { - return enableError; - } - - @NonNull - public Optional> readMDC(@NonNull final Context context) { - return context.getOrEmpty(mdcContextKey); - } - - public String getName() { - return logger.getName(); - } - - //region Trace - public boolean isTraceEnabled() { - return logger.isTraceEnabled(); - } - - @NonNull - public Mono trace(@NonNull final String msg) { - return wrap(() -> logger.trace(msg)); - } - - @NonNull - public Mono trace(final String format, final Object... arguments) { - return wrap(() -> logger.trace(format, arguments)); - } - - @NonNull - public Mono trace(final String msg, final Throwable t) { - return wrap(() -> logger.trace(msg, t)); - } - - public boolean isTraceEnabled(final Marker marker) { - return logger.isTraceEnabled(marker); - } - - @NonNull - public Mono trace(final Marker marker, final String msg) { - return wrap(() -> logger.trace(marker, msg)); - } - - @NonNull - public Mono trace(final Marker marker, final String format, final Object... argArray) { - return wrap(() -> logger.trace(marker, format, argArray)); - } - - @NonNull - public Mono trace( - final Marker marker, final String msg, final Throwable t - ) { - return wrap(() -> logger.trace(marker, msg, t)); - } - //endregion - - //region Debug - public boolean isDebugEnabled() { - return logger.isDebugEnabled(); - } - - @NonNull - public Mono debug(final String msg) { - return wrap(() -> logger.debug(msg)); - } - - @NonNull - public Mono debug(final String format, final Object... arguments) { - return wrap(() -> logger.debug(format, arguments)); - } - - @NonNull - public Mono debug(final String msg, final Throwable t) { - return wrap(() -> logger.debug(msg, t)); - } - - public boolean isDebugEnabled(final Marker marker) { - return logger.isDebugEnabled(marker); - } - - @NonNull - public Mono debug(final Marker marker, final String msg) { - return wrap(() -> logger.debug(marker, msg)); - } - - @NonNull - public Mono debug(final Marker marker, final String format, final Object... arguments) { - return wrap(() -> logger.debug(marker, format, arguments)); - } - - @NonNull - public Mono debug(final Marker marker, final String msg, final Throwable t) { - return wrap(() -> logger.debug(marker, msg, t)); - } - //endregion - - //region Info - public boolean isInfoEnabled() { - return logger.isInfoEnabled(); - } - - @NonNull - public Mono info(final String msg) { - return wrap(() -> logger.info(msg)); - } - - @NonNull - public Mono info(final String format, final Object... arguments) { - return wrap(() -> logger.info(format, arguments)); - } - - @NonNull - public Mono info(final String msg, final Throwable t) { - return wrap(() -> logger.info(msg, t)); - } - - public boolean isInfoEnabled(final Marker marker) { - return logger.isInfoEnabled(marker); - } - - @NonNull - public Mono info(final Marker marker, final String msg) { - return wrap(() -> logger.info(marker, msg)); - } - - @NonNull - public Mono info(final Marker marker, final String format, final Object... arguments) { - return wrap(() -> logger.info(marker, format, arguments)); - } - - @NonNull - public Mono info( - final Marker marker, final String msg, final Throwable t - ) { - return wrap(() -> logger.info(marker, msg, t)); - } - //endregion - - //region Warn - public boolean isWarnEnabled() { - return logger.isWarnEnabled(); - } - - @NonNull - public Mono warn(final String msg) { - return wrap(() -> logger.warn(msg)); - } - - @NonNull - public Mono warn(final String format, final Object... arguments) { - return wrap(() -> logger.warn(format, arguments)); - } - - @NonNull - public Mono warn(final String msg, final Throwable t) { - return wrap(() -> logger.warn(msg, t)); - } - - public boolean isWarnEnabled(final Marker marker) { - return logger.isWarnEnabled(marker); - } - - @NonNull - public Mono warn(final Marker marker, final String msg) { - return wrap(() -> logger.warn(marker, msg)); - } - - @NonNull - public Mono warn(final Marker marker, final String format, final Object... arguments) { - return wrap(() -> logger.warn(marker, format, arguments)); - } - - @NonNull - public Mono warn(final Marker marker, final String msg, final Throwable t) { - return wrap(() -> logger.warn(marker, msg, t)); - } - //endregion - - //region Error - public boolean isErrorEnabled() { - return logger.isErrorEnabled(); - } - - @NonNull - public Mono error(final String msg) { - return wrap(() -> logger.error(msg)); - } - - @NonNull - public Mono error(final String format, final Object... arguments) { - return wrap(() -> logger.error(format, arguments)); - } - - @NonNull - public Mono error(final String msg, final Throwable t) { - return wrap(() -> logger.error(msg, t)); - } - - public boolean isErrorEnabled(final Marker marker) { - return logger.isErrorEnabled(marker); - } - - @NonNull - public Mono error(final Marker marker, final String msg) { - return wrap(() -> logger.error(marker, msg)); - } - - @NonNull - public Mono error(final Marker marker, final String format, final Object... arguments) { - return wrap(() -> logger.error(marker, format, arguments)); - } - - @NonNull - public Mono error(final Marker marker, final String msg, final Throwable t) { - return wrap(() -> logger.error(marker, msg, t)); - } - //endregion - - MDCSnapshot takeMDCSnapshot(final Context context) throws ContextNotExistException { - if (enableError) { - return readMDC(context).map(MDCSnapshot::of).orElseThrow(() -> new ContextNotExistException("\"" + mdcContextKey + "\" context not found") ); - } else { - return readMDC(context).map(MDCSnapshot::of).orElseGet(MDCSnapshot::empty); - } - } - - @NonNull - public Mono snapshot(final Context context) { - try { - if (context == null) { - throw new IllegalArgumentException(CTX_NOT_NULL); - } - - MDC mdc; - try (final MDCSnapshot snapshot = takeMDCSnapshot(context)) { - mdc = new MDC(this.mdcContextKey, snapshot.getCopyOfContextMap()); - } - return Mono.just(mdc); - } catch (Exception exception) { - return Mono.error(exception); - } - } - - @NonNull - private Mono wrap(final Runnable runnable) { - return Mono.deferContextual(contextView -> { - Context context = Context.of(contextView); - - try (final MDCSnapshot snapshot = takeMDCSnapshot(context)) { - runnable.run(); - } catch (ContextNotExistException exception) { - return Mono.error(exception); - } - - return Mono.just(context); - }).subscribeOn(scheduler); - } - - public static class Builder { - private Scheduler scheduler = Values.DEFAULT_SCHEDULER; - private Logger logger = DEFAULT_LOGGER; - private String mdcContextKey = Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; - private static final String LOGGER_MUST_NOT_BE_NULL = "logger must not be null"; - private boolean enableError = false; - - private Builder() { - } - - public Builder enableError() { - this.enableError = true; - return this; - } - - public Builder withLogger(@NonNull final Class logger) { - this.logger = LoggerFactory.getLogger(Objects.requireNonNull(logger, LOGGER_MUST_NOT_BE_NULL)); - return this; - } - - public Builder withLogger(@NonNull final String logger) { - this.logger = LoggerFactory.getLogger(Objects.requireNonNull(logger, LOGGER_MUST_NOT_BE_NULL)); - return this; - } - - public Builder withLogger(@NonNull final Logger logger) { - this.logger = Objects.requireNonNull(logger, LOGGER_MUST_NOT_BE_NULL); - return this; - } - - public Builder withScheduler(@NonNull final Scheduler scheduler) { - this.scheduler = Objects.requireNonNull(scheduler, "scheduler must not be null"); - return this; - } - - public Builder withMDCContextKey(@NonNull final String mdcContextKey) { - if (mdcContextKey.trim().isEmpty()) { - throw new IllegalArgumentException("MDC context key must not be blank"); - } - - this.mdcContextKey = mdcContextKey; - return this; - } - - public ReactiveLogger build() { - return new ReactiveLogger(this); - } - } -} diff --git a/src/main/java/io/github/numichi/reactive/logger/kotlin/ReactiveLogger.kt b/src/main/java/io/github/numichi/reactive/logger/kotlin/ReactiveLogger.kt deleted file mode 100644 index 6aab12d..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/kotlin/ReactiveLogger.kt +++ /dev/null @@ -1,332 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.java.ReactiveLogger as JReactiveLogger -import io.github.numichi.reactive.logger.Values -import io.github.numichi.reactive.logger.annotations.JacocoSkipGeneratedReport -import io.github.numichi.reactive.logger.MDC -import kotlinx.coroutines.reactor.ReactorContext -import kotlinx.coroutines.reactor.awaitSingleOrNull -import org.slf4j.Logger -import org.slf4j.LoggerFactory -import org.slf4j.Marker -import reactor.core.publisher.Mono -import reactor.core.scheduler.Scheduler -import reactor.util.context.Context -import java.util.* -import kotlin.coroutines.CoroutineContext -import kotlin.coroutines.coroutineContext - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("ReactiveLogger", "io.github.numichi.reactive.logger.coroutine") -) -class ReactiveLogger private constructor( - private val reactiveLogger: JReactiveLogger, - private val contextKey: CoroutineContext.Key, - private val contextExtractive: suspend (CoroutineContext.Key) -> Context?, -) { - - companion object { - @JvmStatic - fun builder(): Builder { - return builder(ReactorContext).withContext { reactorContextOrEmpty() } - } - - @JvmStatic - fun builder(coroutineKey: CoroutineContext.Key): Builder { - return Builder(coroutineKey) - } - } - - fun readMDC(context: Context): Optional> = reactiveLogger.readMDC(context) - - suspend fun snapshot(context: Context? = null): MDC? { - val ctx = context ?: coroutineContext[ReactorContext]?.context - return reactiveLogger.snapshot(ctx).awaitSingleOrNull() - } - - val imperative: Logger - get() = reactiveLogger.imperative() - - val scheduler: Scheduler - get() = reactiveLogger.scheduler() - - val name: String - get() = reactiveLogger.name - - val mdcContextKey: String - get() = reactiveLogger.mdcContextKey() - - //region Trace - val isTraceEnabled: Boolean - get() = reactiveLogger.isTraceEnabled - - @JacocoSkipGeneratedReport - suspend fun trace(msg: String) { - return wrap { logger -> logger.trace(msg) } - } - - @JacocoSkipGeneratedReport - suspend fun trace(format: String, vararg arguments: Any) { - return wrap { logger -> logger.trace(format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun trace(msg: String, t: Throwable) { - return wrap { logger -> logger.trace(msg, t) } - } - - fun isTraceEnabled(marker: Marker): Boolean { - return reactiveLogger.isTraceEnabled(marker) - } - - @JacocoSkipGeneratedReport - suspend fun trace(marker: Marker, msg: String) { - return wrap { logger -> logger.trace(marker, msg) } - } - - @JacocoSkipGeneratedReport - suspend fun trace(marker: Marker, format: String, vararg argArray: Any) { - return wrap { logger -> logger.trace(marker, format, *argArray) } - } - - @JacocoSkipGeneratedReport - suspend fun trace(marker: Marker, msg: String, t: Throwable) { - return wrap { logger -> logger.trace(marker, msg, t) } - } - //endregion - - //region Debug - val isDebugEnabled: Boolean - get() = reactiveLogger.isDebugEnabled - - @JacocoSkipGeneratedReport - suspend fun debug(msg: String) { - return wrap { logger -> logger.debug(msg) } - } - - @JacocoSkipGeneratedReport - suspend fun debug(format: String, vararg arguments: Any) { - return wrap { logger -> logger.debug(format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun debug(msg: String, t: Throwable) { - return wrap { logger -> logger.debug(msg, t) } - } - - fun isDebugEnabled(marker: Marker): Boolean { - return reactiveLogger.isDebugEnabled(marker) - } - - @JacocoSkipGeneratedReport - suspend fun debug(marker: Marker, msg: String) { - return wrap { logger -> logger.debug(marker, msg) } - } - - @JacocoSkipGeneratedReport - suspend fun debug(marker: Marker, format: String, vararg arguments: Any) { - return wrap { logger -> logger.debug(marker, format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun debug(marker: Marker, msg: String, t: Throwable) { - return wrap { logger -> logger.debug(marker, msg, t) } - } - //endregion - - //region Info - val isInfoEnabled: Boolean - get() = reactiveLogger.isInfoEnabled - - @JacocoSkipGeneratedReport - suspend fun info(msg: String) { - return wrap { logger -> logger.info(msg) } - } - - @JacocoSkipGeneratedReport - suspend fun info(format: String, vararg arguments: Any) { - return wrap { logger -> logger.info(format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun info(msg: String, t: Throwable) { - return wrap { logger -> logger.info(msg, t) } - } - - fun isInfoEnabled(marker: Marker): Boolean { - return reactiveLogger.isInfoEnabled(marker) - } - - @JacocoSkipGeneratedReport - suspend fun info(marker: Marker, msg: String) { - return wrap { logger -> logger.info(marker, msg) } - } - - @JacocoSkipGeneratedReport - suspend fun info(marker: Marker, format: String, vararg arguments: Any) { - return wrap { logger -> logger.info(marker, format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun info(marker: Marker, msg: String, t: Throwable) { - return wrap { logger -> logger.info(marker, msg, t) } - } - //endregion - - //region Warn - val isWarnEnabled: Boolean - get() = reactiveLogger.isWarnEnabled - - @JacocoSkipGeneratedReport - suspend fun warn(msg: String) { - return wrap { logger -> logger.warn(msg) } - } - - @JacocoSkipGeneratedReport - suspend fun warn(format: String, vararg arguments: Any) { - return wrap { logger -> logger.warn(format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun warn(msg: String, t: Throwable) { - return wrap { logger -> logger.warn(msg, t) } - } - - fun isWarnEnabled(marker: Marker): Boolean { - return reactiveLogger.isWarnEnabled(marker) - } - - @JacocoSkipGeneratedReport - suspend fun warn(marker: Marker, msg: String) { - return wrap { logger -> logger.warn(marker, msg) } - } - - @JacocoSkipGeneratedReport - suspend fun warn(marker: Marker, format: String, vararg arguments: Any) { - return wrap { logger -> logger.warn(marker, format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun warn(marker: Marker, msg: String, t: Throwable) { - return wrap { logger -> logger.warn(marker, msg, t) } - } - //endregion - - //region Error - val isErrorEnabled: Boolean - get() = reactiveLogger.isErrorEnabled - - @JacocoSkipGeneratedReport - suspend fun error(msg: String) { - return wrap { logger -> logger.error(msg) } - } - - @JacocoSkipGeneratedReport - suspend fun error(format: String, vararg arguments: Any) { - return wrap { logger -> logger.error(format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun error(msg: String, t: Throwable) { - return wrap { logger -> logger.error(msg, t) } - } - - fun isErrorEnabled(marker: Marker): Boolean { - return reactiveLogger.isErrorEnabled(marker) - } - - @JacocoSkipGeneratedReport - suspend fun error(marker: Marker, msg: String) { - return wrap { logger -> logger.error(marker, msg) } - } - - @JacocoSkipGeneratedReport - suspend fun error(marker: Marker, format: String, vararg arguments: Any) { - return wrap { logger -> logger.error(marker, format, *arguments) } - } - - @JacocoSkipGeneratedReport - suspend fun error(marker: Marker, msg: String, t: Throwable) { - return wrap { logger -> logger.error(marker, msg, t) } - } - //endregion - - private suspend fun wrap(fn: (JReactiveLogger) -> Mono) { - val context = contextExtractive(contextKey) - - requireNotNull(context) { "Context configuration is null! The resulting context is null. Use withContext via Builder." } - - fn(reactiveLogger) - .contextWrite { it.putAll(context.readOnly()) } - .awaitSingleOrNull() - } - - class Builder(private val contextKey: CoroutineContext.Key) { - private var scheduler = Values.DEFAULT_SCHEDULER - private var logger = LoggerFactory.getLogger(ReactiveLogger::class.java) - private var mdcContextKey = Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY - private var contextExtractive: suspend (CoroutineContext.Key) -> Context? - private var enableError: Boolean = false - - init { - contextExtractive = { null } - } - - fun enableError(): Builder { - enableError = true - return this - } - - fun withLogger(logger: Class<*>): Builder { - this.logger = LoggerFactory.getLogger(logger) - return this - } - - fun withLogger(logger: String): Builder { - this.logger = LoggerFactory.getLogger(logger) - return this - } - - fun withLogger(logger: Logger): Builder { - this.logger = logger - return this - } - - fun withScheduler(scheduler: Scheduler): Builder { - this.scheduler = scheduler - return this - } - - fun withMDCContextKey(mdcContextKey: String): Builder { - require(mdcContextKey.trim().isNotEmpty()) { "MDC context key must not be blank" } - - this.mdcContextKey = mdcContextKey - return this - } - - fun withContext(extractive: suspend (CoroutineContext.Key) -> Context?): Builder { - this.contextExtractive = extractive - return this - } - - @Suppress("UNCHECKED_CAST") - fun build(): ReactiveLogger { - val jLogger = JReactiveLogger.builder() - .withLogger(logger) - .withScheduler(scheduler) - .withMDCContextKey(mdcContextKey) - - if (enableError) { - jLogger.enableError() - } - - return ReactiveLogger( - jLogger.build(), - contextKey, - contextExtractive as suspend (CoroutineContext.Key) -> Context?, - ) - } - } -} - diff --git a/src/main/java/io/github/numichi/reactive/logger/kotlin/helper.kt b/src/main/java/io/github/numichi/reactive/logger/kotlin/helper.kt deleted file mode 100644 index 791e53c..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/kotlin/helper.kt +++ /dev/null @@ -1,32 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.annotations.JacocoSkipGeneratedReport -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.reactor.ReactorContext -import kotlinx.coroutines.reactor.asCoroutineContext -import reactor.util.context.Context -import kotlin.coroutines.coroutineContext - -@JacocoSkipGeneratedReport -internal suspend fun reactorContextOrEmpty(): Context { - return rectorContext() ?: Context.empty() -} - -internal suspend fun rectorContext(): Context? { - return coroutineContext[ReactorContext]?.context -} - -internal fun mdcCollectionIntoContext(context: Context, iterator: Iterator): Context { - var writableContext = context - iterator.forEach { - writableContext = writableContext.put(it.contextKey, it.asMap()) - } - return writableContext -} - -internal suspend fun withContextBlock(context: Context, iterator: Iterator, block: suspend CoroutineScope.() -> T): T { - return kotlinx.coroutines.withContext(mdcCollectionIntoContext(context, iterator).asCoroutineContext()) { - block() - } -} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/kotlin/putMDC.kt b/src/main/java/io/github/numichi/reactive/logger/kotlin/putMDC.kt deleted file mode 100644 index 01269e4..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/kotlin/putMDC.kt +++ /dev/null @@ -1,12 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.MDC -import reactor.util.context.Context - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("putMdc(context, mdc)", "io.github.numichi.reactive.logger.coroutine") -) -fun putMdc(context: Context, vararg mdc: MDC): Context { - return mdcCollectionIntoContext(context, mdc.iterator()) -} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/kotlin/readMDC.kt b/src/main/java/io/github/numichi/reactive/logger/kotlin/readMDC.kt deleted file mode 100644 index 2f5c1f2..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/kotlin/readMDC.kt +++ /dev/null @@ -1,49 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.Values -import io.github.numichi.reactive.logger.exception.InvalidContextDataException -import reactor.util.context.ContextView - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("readMDC()", "io.github.numichi.reactive.logger.coroutine") -) -suspend fun readMDC(): MDC { - return readMDC(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY) -} - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("readMDC(mdcContextKey)", "io.github.numichi.reactive.logger.coroutine") -) -suspend fun readMDC(mdcContextKey: String): MDC { - return readMDC(rectorContext(), mdcContextKey) -} - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("readMDC(contextView)", "io.github.numichi.reactive.logger.coroutine") -) -fun readMDC(contextView: ContextView?): MDC { - return readMDC(contextView, Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY) -} - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith("readMDC(contextView, mdcContextKey)", "io.github.numichi.reactive.logger.coroutine") -) -fun readMDC(contextView: ContextView?, mdcContextKey: String): MDC { - requireNotNull(contextView) { "contentView must not be null" } - - val mdc = MDC(mdcContextKey) - - try { - val map: Map = contextView.get(mdcContextKey) - mdc.putAll(map) - } catch (exception: Exception) { - throw InvalidContextDataException(exception) - } - - return mdc -} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/kotlin/withMDCContext.kt b/src/main/java/io/github/numichi/reactive/logger/kotlin/withMDCContext.kt deleted file mode 100644 index 9b8e38d..0000000 --- a/src/main/java/io/github/numichi/reactive/logger/kotlin/withMDCContext.kt +++ /dev/null @@ -1,29 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.MDC -import kotlinx.coroutines.CoroutineScope - -import reactor.util.context.Context - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith( - "withMDCContext(mdc, block)", - "io.github.numichi.reactive.logger.coroutine" - ) -) -suspend fun withMDCContext(vararg mdc: MDC, block: suspend CoroutineScope.() -> T): T { - return withContextBlock(reactorContextOrEmpty(), mdc.iterator(), block) -} - -@Deprecated( - "we are going to replace from coroutine package", - ReplaceWith( - "withMDCContext(context, mdc, block)", - "io.github.numichi.reactive.logger.coroutine" - ) -) -suspend fun withMDCContext(context: Context?, vararg mdc: MDC, block: suspend CoroutineScope.() -> T): T { - requireNotNull(context) { "context must not be null" } - return withContextBlock(context, mdc.iterator(), block) -} \ No newline at end of file diff --git a/src/main/java/io/github/numichi/reactive/logger/reactor/MDCContext.java b/src/main/java/io/github/numichi/reactive/logger/reactor/MDCContext.java index acf072e..4a5eee1 100644 --- a/src/main/java/io/github/numichi/reactive/logger/reactor/MDCContext.java +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/MDCContext.java @@ -1,7 +1,7 @@ package io.github.numichi.reactive.logger.reactor; import io.github.numichi.reactive.logger.MDC; -import io.github.numichi.reactive.logger.Values; +import io.github.numichi.reactive.logger.DefaultValues; import io.github.numichi.reactive.logger.exception.InvalidContextDataException; import reactor.core.publisher.Mono; import reactor.util.annotation.NonNull; @@ -41,7 +41,7 @@ public static Context put(Context context, MDC... mdc) { @NonNull public static Mono read() { - return read(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY); + return read(DefaultValues.getInstance().getDefaultReactorContextMdcKey()); } @NonNull @@ -51,7 +51,7 @@ public static Mono read(String mdcContextKey) { @NonNull public static Mono read(ContextView context) { - return read(context, Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY); + return read(context, DefaultValues.getInstance().getDefaultReactorContextMdcKey()); } @NonNull diff --git a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.java b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.java index 528400e..5386089 100644 --- a/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.java +++ b/src/main/java/io/github/numichi/reactive/logger/reactor/ReactiveLogger.java @@ -1,7 +1,7 @@ package io.github.numichi.reactive.logger.reactor; import io.github.numichi.reactive.logger.MDC; -import io.github.numichi.reactive.logger.Values; +import io.github.numichi.reactive.logger.DefaultValues; import io.github.numichi.reactive.logger.exception.ContextNotExistException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -307,9 +307,9 @@ private Mono wrap(final Runnable runnable) { } public static class Builder { - private Scheduler scheduler = Values.DEFAULT_SCHEDULER; + private Scheduler scheduler = DefaultValues.getInstance().getDefaultScheduler(); private Logger logger = DEFAULT_LOGGER; - private String mdcContextKey = Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; + private String mdcContextKey = DefaultValues.getInstance().getDefaultReactorContextMdcKey(); private static final String LOGGER_MUST_NOT_BE_NULL = "logger must not be null"; private boolean enableError = false; 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 eda119f..02f2120 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 @@ -1,6 +1,6 @@ package io.github.numichi.reactive.logger.coroutine -import io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY +import io.github.numichi.reactive.logger.DefaultValues import io.github.numichi.reactive.logger.MDC import io.github.numichi.reactive.logger.exception.InvalidContextDataException import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -31,11 +31,11 @@ internal class MDCContextTest { assertEquals(0, result0.size()) val result1 = putMdc(Context.empty(), mdc1) - assertEquals(mdc1.asMap(), result1.getOrEmpty>(DEFAULT_REACTOR_CONTEXT_MDC_KEY).orElse(null)) + assertEquals(mdc1.asMap(), result1.getOrEmpty>(DefaultValues.getInstance().defaultReactorContextMdcKey).orElse(null)) assertEquals(1, result1.size()) val result2 = putMdc(Context.empty(), mdc1, mdc2) - assertEquals(mdc1.asMap(), result2.getOrEmpty>(DEFAULT_REACTOR_CONTEXT_MDC_KEY).orElse(null)) + assertEquals(mdc1.asMap(), result2.getOrEmpty>(DefaultValues.getInstance().defaultReactorContextMdcKey).orElse(null)) assertEquals(mdc2.asMap(), result2.getOrEmpty>(ANOTHER_CONTEXT_KEY).orElse(null)) assertEquals(2, result2.size()) } @@ -68,7 +68,7 @@ internal class MDCContextTest { val mdcMap = mutableMapOf() mdcMap["mdcKey"] = "mdcValue" - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to mdcMap)).asCoroutineContext()) { + withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to mdcMap)).asCoroutineContext()) { val result = readMDC(coroutineContext[ReactorContext]?.context) assertEquals(mdcMap, result) assertEquals(mdcMap, result.asMap()) @@ -96,8 +96,8 @@ internal class MDCContextTest { withMDCContext(mdc1, mdc2) { val result1 = readMDC(coroutineContext[ReactorContext]?.context) - val result2 = readMDC(coroutineContext[ReactorContext]?.context, DEFAULT_REACTOR_CONTEXT_MDC_KEY) - val result3 = readMDC(DEFAULT_REACTOR_CONTEXT_MDC_KEY) + 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) @@ -143,11 +143,11 @@ internal class MDCContextTest { @Test fun `should throw InvalidContextDataException if context data is invalid`() = runTest { - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to 10)).asCoroutineContext()) { + withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to 10)).asCoroutineContext()) { assertThrows { readMDC() } } - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to "any")).asCoroutineContext()) { + withContext(Context.of(mapOf(DefaultValues.getInstance().defaultReactorContextMdcKey to "any")).asCoroutineContext()) { assertThrows { readMDC() } } } diff --git a/src/test/java/io/github/numichi/reactive/logger/coroutine/ReactiveLoggerTest.kt b/src/test/java/io/github/numichi/reactive/logger/coroutine/ReactiveLoggerTest.kt index 4900eb7..3669d61 100644 --- a/src/test/java/io/github/numichi/reactive/logger/coroutine/ReactiveLoggerTest.kt +++ b/src/test/java/io/github/numichi/reactive/logger/coroutine/ReactiveLoggerTest.kt @@ -1,7 +1,6 @@ package io.github.numichi.reactive.logger.coroutine -import io.github.numichi.reactive.logger.Values -import io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY +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.coroutine.MDCContextTest.Companion.ANOTHER_CONTEXT_KEY @@ -76,7 +75,7 @@ internal class ReactiveLoggerTest { val mdc = MDC() mdc[randomText()] = randomText() var context1 = Context.empty() - context1 = context1.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc.asMap()) + context1 = context1.put(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc.asMap()) var context2 = Context.empty() context2 = context2.put(ANOTHER_CONTEXT_KEY, mdc.asMap()) @@ -128,7 +127,7 @@ internal class ReactiveLoggerTest { @Test fun readMDC() { val mdc: Map = randomMap(1) - val context = Context.of(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc) + val context = Context.of(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc) assertEquals(Optional.of(mdc), logger.readMDC(context)) assertEquals(Optional.of(mdc).get(), logger.readMDC(context).get()) } diff --git a/src/test/java/io/github/numichi/reactive/logger/java/MDCContextTest.java b/src/test/java/io/github/numichi/reactive/logger/java/MDCContextTest.java deleted file mode 100644 index ba21fce..0000000 --- a/src/test/java/io/github/numichi/reactive/logger/java/MDCContextTest.java +++ /dev/null @@ -1,181 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import io.github.numichi.reactive.logger.MDC; -import io.github.numichi.reactive.logger.exception.InvalidContextDataException; -import io.github.numichi.reactive.logger.java.MDCContext; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import reactor.core.publisher.Mono; -import reactor.test.StepVerifier; -import reactor.util.context.Context; - -import java.util.HashMap; -import java.util.Map; - -import static io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; -import static org.junit.jupiter.api.Assertions.assertThrows; - -class MDCContextTest { - - public static final String ANOTHER_CONTEXT_KEY = "another-context-key"; - - @Test - @DisplayName("should give the MDC you are looking for") - void shouldGiveTheMDCByDefault() { - MDC mdc1 = new MDC(); - mdc1.put("mdcKey", "mdcValue"); - - MDC mdc2 = new MDC(ANOTHER_CONTEXT_KEY); - mdc2.put("mdcKey", "mdcValue"); - - - Mono resultDefaultByContext = Mono.deferContextual(MDCContext::read) - .contextWrite(it -> MDCContext.put(it, mdc1)); - - StepVerifier.create(resultDefaultByContext) - .expectNext(mdc1) - .verifyComplete(); - - - Mono resultDefault = Mono.defer(MDCContext::read) - .contextWrite(it -> MDCContext.put(it, mdc1)); - - StepVerifier.create(resultDefault) - .expectNext(mdc1) - .verifyComplete(); - - - Mono resultAnotherByContext = Mono.deferContextual(ctx -> MDCContext.read(ctx, ANOTHER_CONTEXT_KEY)) - .contextWrite(it -> MDCContext.put(it, mdc2)); - - StepVerifier.create(resultAnotherByContext) - .expectNext(mdc2) - .verifyComplete(); - - - Mono resultAnother = Mono.defer(() -> MDCContext.read(ANOTHER_CONTEXT_KEY)) - .contextWrite(it -> MDCContext.put(it, mdc2)); - - StepVerifier.create(resultAnother) - .expectNext(mdc2) - .verifyComplete(); - } - - @Test - @DisplayName("should return the appropriate contexts count") - void shouldReturnTheAppropriateContextsCount() { - MDC defaultMdc = new MDC(); - defaultMdc.put("mdcKey", "mdcValue"); - - MDC anotherMdc = new MDC(ANOTHER_CONTEXT_KEY); - anotherMdc.put("mdcKey", "mdcValue"); - - Mono contextSize1 = Mono.deferContextual(ctx -> Mono.just(ctx.size())) - .contextWrite(it -> MDCContext.put(it, defaultMdc)) - .contextWrite(it -> MDCContext.put(it, anotherMdc)); - StepVerifier.create(contextSize1) - .expectNext(2) - .verifyComplete(); - - - Mono contextSize2 = Mono.deferContextual(ctx -> Mono.just(ctx.size())) - .contextWrite(it -> MDCContext.put(it, defaultMdc, anotherMdc)); - StepVerifier.create(contextSize2) - .expectNext(2) - .verifyComplete(); - - - Mono contextSize3 = Mono.deferContextual(ctx -> Mono.just(ctx.size())) - .contextWrite(it -> MDCContext.put(it, defaultMdc, null)); - StepVerifier.create(contextSize3) - .expectNext(1) - .verifyComplete(); - - - Mono contextSize4 = Mono.deferContextual(ctx -> Mono.just(ctx.size())) - .contextWrite(it -> MDCContext.put(it, defaultMdc, null)) - .contextWrite(it -> it.put("A", "B")); - StepVerifier.create(contextSize4) - .expectNext(2) - .verifyComplete(); - } - - @Test - @DisplayName("should give the MDC you are looking for (more MDC Context)") - void shouldGiveTheMDCWithMoreMdcContext() { - MDC defaultMdc = new MDC(); - defaultMdc.put("mdcKey", "mdcValue"); - - MDC anotherMdc = new MDC(ANOTHER_CONTEXT_KEY); - anotherMdc.put("mdcKey", "mdcValue"); - - - Mono resultDefault = Mono.defer(MDCContext::read) - .contextWrite(it -> MDCContext.put(it, defaultMdc)) - .contextWrite(it -> MDCContext.put(it, anotherMdc)); - StepVerifier.create(resultDefault) - .expectNext(defaultMdc) - .verifyComplete(); - - - Mono resultAnother = Mono.defer(() -> MDCContext.read(ANOTHER_CONTEXT_KEY)) - .contextWrite(it -> MDCContext.put(it, defaultMdc)) - .contextWrite(it -> MDCContext.put(it, anotherMdc)); - StepVerifier.create(resultAnother) - .expectNext(anotherMdc) - .verifyComplete(); - } - - @Test - @DisplayName("should throw IllegalArgumentException if any parameter is NULL") - void shouldThrowIllegalArgumentExceptionTest() { - assertThrows(IllegalArgumentException.class, () -> MDCContext.put(null, new MDC())); - assertThrows(IllegalArgumentException.class, () -> MDCContext.put(Context.empty(), null)); - - StepVerifier.create(MDCContext.read((String) null)) - .expectError(IllegalArgumentException.class) - .verify(); - - StepVerifier.create(MDCContext.read(null, "")) - .expectError(IllegalArgumentException.class) - .verify(); - - StepVerifier.create(MDCContext.read(Context.of("", ""), null)) - .expectError(IllegalArgumentException.class) - .verify(); - } - - @Test - @DisplayName("should throw InvalidContextDataException if context data is invalid") - void shouldThrowInvalidContextDataException() { - // ANOTHER_CONTEXT_KEY is not DEFAULT_REACTOR_CONTEXT_MDC_KEY - MDC mdc = new MDC(ANOTHER_CONTEXT_KEY); - mdc.put("mdcKey2", "mdcValue2"); - Mono result1 = Mono.defer(MDCContext::read) - .contextWrite(it -> MDCContext.put(it, mdc)); - StepVerifier.create(result1) - .expectError(InvalidContextDataException.class) - .verify(); - - - Mono result2 = Mono.defer(() -> MDCContext.read("not-exist-context-id")) - .contextWrite(it -> MDCContext.put(it, mdc)); - StepVerifier.create(result2) - .expectError(InvalidContextDataException.class) - .verify(); - - - Mono result3 = Mono.defer(MDCContext::read) - .contextWrite(it -> it.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, "")); - StepVerifier.create(result3) - .expectError(InvalidContextDataException.class) - .verify(); - - - Mono result4 = Mono.defer(MDCContext::read) - .contextWrite(it -> it.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, 100)); - StepVerifier.create(result4) - .expectError(InvalidContextDataException.class) - .verify(); - } -} \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/java/MDCSnapshotTest.java b/src/test/java/io/github/numichi/reactive/logger/java/MDCSnapshotTest.java deleted file mode 100644 index d327061..0000000 --- a/src/test/java/io/github/numichi/reactive/logger/java/MDCSnapshotTest.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import io.github.numichi.reactive.logger.java.MDCSnapshot; -import org.junit.jupiter.api.Test; -import org.slf4j.MDC; - -import java.util.HashMap; -import java.util.Map; -import java.util.UUID; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -class MDCSnapshotTest { - - static String randomText() { - return UUID.randomUUID().toString(); - } - - @Test - void populateAndClear() { - final Map expected = new HashMap<>(); - expected.put(randomText(), randomText()); - expected.put(randomText(), randomText()); - - assertEquals(new HashMap<>(), MDC.getCopyOfContextMap()); - - try (final MDCSnapshot snapshot = MDCSnapshot.of(expected)) { - assertEquals(MDC.getCopyOfContextMap(), expected); - } - - assertEquals(new HashMap<>(), MDC.getCopyOfContextMap()); - } - - @Test - void createEmptyInstance() { - MDC.put(randomText(), randomText()); - - try (final MDCSnapshot snapshot = MDCSnapshot.empty()) { - assertEquals(new HashMap<>(), MDC.getCopyOfContextMap()); - } - } -} \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/java/ReactiveLoggerTest.java b/src/test/java/io/github/numichi/reactive/logger/java/ReactiveLoggerTest.java deleted file mode 100644 index 528ac3e..0000000 --- a/src/test/java/io/github/numichi/reactive/logger/java/ReactiveLoggerTest.java +++ /dev/null @@ -1,552 +0,0 @@ -package io.github.numichi.reactive.logger.java; - -import io.github.numichi.reactive.logger.exception.ContextNotExistException; -import io.github.numichi.reactive.logger.MDC; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.mockito.ArgumentCaptor; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.slf4j.Marker; -import org.slf4j.MarkerFactory; -import reactor.core.publisher.Mono; -import reactor.core.scheduler.Scheduler; -import reactor.core.scheduler.Schedulers; -import reactor.test.StepVerifier; -import reactor.util.annotation.NonNull; -import reactor.util.context.Context; - -import java.util.HashMap; -import java.util.Map; -import java.util.Optional; -import java.util.UUID; - -import static io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.reset; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -class ReactiveLoggerTest { - - private final Logger imperativeLogger = mock(Logger.class); - private final ReactiveLogger logger = ReactiveLogger.builder().withLogger(imperativeLogger).build(); - private final ReactiveLogger loggerWithError = ReactiveLogger.builder().withLogger(imperativeLogger).enableError().build(); - - static String randomText() { - return UUID.randomUUID().toString(); - } - - @NonNull - static Map randomMap(int i) { - final Map expected = new HashMap<>(); - - while (0 < i) { - expected.put(randomText(), randomText()); - i--; - } - - return expected; - } - - @BeforeEach - void afterEach() { - reset(imperativeLogger); - } - - @Test - @SuppressWarnings("squid:S5778") - void builderWithClassLogger() { - assertThrows(NullPointerException.class, () -> ReactiveLogger.builder().withLogger((Class) null).build()); - assertThrows(NullPointerException.class, () -> ReactiveLogger.builder().withLogger((String) null).build()); - assertThrows(NullPointerException.class, () -> ReactiveLogger.builder().withLogger((Logger) null).build()); - - assertNotNull(ReactiveLogger.builder().withLogger(this.getClass()).build()); - assertNotNull(ReactiveLogger.builder().withLogger("any").build()); - assertNotNull(ReactiveLogger.builder().withLogger(LoggerFactory.getLogger(this.getClass())).build()); - } - - @Test - void getName() { - final String name = randomText(); - when(imperativeLogger.getName()).thenReturn(name); - assertEquals(name, logger.getName()); - } - - @Test - void readMDC() { - final Map mdc = randomMap(1); - final Context context = Context.of(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc); - assertEquals(Optional.of(mdc), logger.readMDC(context)); - assertEquals(Optional.of(mdc).get(), logger.readMDC(context).get()); - } - - @Test - void takeMDCSnapshot() { - final Map mdc = randomMap(1); - final Context context = Context.of(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc); - try (final MDCSnapshot snapshot = logger.takeMDCSnapshot(context)) { - assertEquals(org.slf4j.MDC.getCopyOfContextMap(), mdc); - } - } - - @Test - void imperative() { - assertSame(logger.imperative(), imperativeLogger); - assertSame(loggerWithError.imperative(), imperativeLogger); - } - - @Test - void snapshot() { - MDC mdc = new MDC(); - mdc.put(randomText(), randomText()); - - Context context1 = Context.empty(); - context1 = context1.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc.asMap()); - Mono snapshot1 = logger.snapshot(context1); - StepVerifier.create(snapshot1) - .expectNextMatches(mdc1 -> mdc1.asMap().equals(mdc.asMap())) - .verifyComplete(); - - - Context context2 = Context.empty(); - context2 = context2.put(MDCContextTest.ANOTHER_CONTEXT_KEY, mdc.asMap()); - - - Mono snapshot2 = logger.snapshot(context2); - StepVerifier.create(snapshot2) - .expectNextMatches(mdc1 -> mdc1.asMap().size() == 0) - .verifyComplete(); - - - Mono snapshot3 = loggerWithError.snapshot(context2); - StepVerifier.create(snapshot3) - .expectError(ContextNotExistException.class) - .verify(); - - Mono snapshot4 = loggerWithError.snapshot(null); - StepVerifier.create(snapshot4) - .expectError(IllegalArgumentException.class) - .verify(); - } - - @Test - void contextKey() { - final String contextKey = "another-context-key"; - final ReactiveLogger loggerWithCustomScheduler = ReactiveLogger.builder().withMDCContextKey(contextKey).build(); - assertSame(loggerWithCustomScheduler.mdcContextKey(), contextKey); - - assertThrows(IllegalArgumentException.class, () -> ReactiveLogger.builder().withMDCContextKey("").build()); - assertThrows(IllegalArgumentException.class, () -> ReactiveLogger.builder().withMDCContextKey(" ").build()); - } - - @Test - void scheduler() { - final Scheduler customScheduler = Schedulers.newBoundedElastic(10, 10, randomText()); - final ReactiveLogger loggerWithCustomScheduler = ReactiveLogger.builder().withScheduler(customScheduler).build(); - assertSame(loggerWithCustomScheduler.scheduler(), customScheduler); - } - - @Test - void traceEnabled() { - when(imperativeLogger.isTraceEnabled()).thenReturn(true, false, true); - assertTrue(logger.isTraceEnabled(), "trace not enabled when it should be"); - assertFalse(logger.isTraceEnabled(), "trace enabled when it should not be"); - assertTrue(logger.isTraceEnabled(), "trace not enabled when it should be"); - } - - @Test - void traceEnabledMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - when(imperativeLogger.isTraceEnabled(marker)).thenReturn(true, false, true); - assertTrue(logger.isTraceEnabled(marker), "trace not enabled when it should be"); - assertFalse(logger.isTraceEnabled(marker), "trace enabled when it should not be"); - assertTrue(logger.isTraceEnabled(marker), "trace not enabled when it should be"); - } - - @Test - void debugEnabled() { - when(imperativeLogger.isDebugEnabled()).thenReturn(true, false, true); - assertTrue(logger.isDebugEnabled(), "debug not enabled when it should be"); - assertFalse(logger.isDebugEnabled(), "debug enabled when it should not be"); - assertTrue(logger.isDebugEnabled(), "debug not enabled when it should be"); - } - - @Test - void debugEnabledMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - when(imperativeLogger.isDebugEnabled(marker)).thenReturn(true, false, true); - assertTrue(logger.isDebugEnabled(marker), "debug not enabled when it should be"); - assertFalse(logger.isDebugEnabled(marker), "debug enabled when it should not be"); - assertTrue(logger.isDebugEnabled(marker), "debug not enabled when it should be"); - } - - @Test - void infoEnabled() { - when(imperativeLogger.isInfoEnabled()).thenReturn(true, false, true); - assertTrue(logger.isInfoEnabled(), "info not enabled when it should be"); - assertFalse(logger.isInfoEnabled(), "info enabled when it should not be"); - assertTrue(logger.isInfoEnabled(), "info not enabled when it should be"); - } - - @Test - void infoEnabledMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - when(imperativeLogger.isInfoEnabled(marker)).thenReturn(true, false, true); - assertTrue(logger.isInfoEnabled(marker), "info not enabled when it should be"); - assertFalse(logger.isInfoEnabled(marker), "info enabled when it should not be"); - assertTrue(logger.isInfoEnabled(marker), "info not enabled when it should be"); - } - - @Test - void warnEnabled() { - when(imperativeLogger.isWarnEnabled()).thenReturn(true, false, true); - assertTrue(logger.isWarnEnabled(), "warn not enabled when it should be"); - assertFalse(logger.isWarnEnabled(), "warn enabled when it should not be"); - assertTrue(logger.isWarnEnabled(), "warn not enabled when it should be"); - } - - @Test - void warnEnabledMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - when(imperativeLogger.isWarnEnabled(marker)).thenReturn(true, false, true); - assertTrue(logger.isWarnEnabled(marker), "warn not enabled when it should be"); - assertFalse(logger.isWarnEnabled(marker), "warn enabled when it should not be"); - assertTrue(logger.isWarnEnabled(marker), "warn not enabled when it should be"); - } - - @Test - void errorEnabled() { - when(imperativeLogger.isErrorEnabled()).thenReturn(true, false, true); - assertTrue(logger.isErrorEnabled(), "error not enabled when it should be"); - assertFalse(logger.isErrorEnabled(), "error enabled when it should not be"); - assertTrue(logger.isErrorEnabled(), "error not enabled when it should be"); - } - - @Test - void errorEnabledMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - when(imperativeLogger.isErrorEnabled(marker)).thenReturn(true, false, true); - assertTrue(logger.isErrorEnabled(marker), "error not enabled when it should be"); - assertFalse(logger.isErrorEnabled(marker), "error enabled when it should not be"); - assertTrue(logger.isErrorEnabled(marker), "error not enabled when it should be"); - } - - @Test - void traceMessage() { - final String message = randomText(); - logger.trace(message).block(); - verify(imperativeLogger).trace(message); - } - - @Test - void traceFormatArgumentArray() { - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.trace(format, argument1, argument2, argument3).block(); - verify(imperativeLogger).trace(format, argument1, argument2, argument3); - } - - @Test - void traceMessageThrowable() { - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.trace(message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).trace(eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void traceMessageMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - logger.trace(marker, message).block(); - verify(imperativeLogger).trace(marker, message); - } - - @Test - void traceFormatArgumentArrayMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.trace(marker, format, argument1, argument2, argument3).block(); - verify(imperativeLogger).trace(marker, format, argument1, argument2, argument3); - } - - @Test - void traceMessageThrowableMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.trace(marker, message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).trace(eq(marker), eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void debugMessage() { - final String message = randomText(); - logger.debug(message).block(); - verify(imperativeLogger).debug(message); - } - - @Test - void debugFormatArgumentArray() { - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.debug(format, argument1, argument2, argument3).block(); - verify(imperativeLogger).debug(format, argument1, argument2, argument3); - } - - @Test - void debugMessageThrowable() { - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.debug(message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).debug(eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void debugMessageMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - logger.debug(marker, message).block(); - verify(imperativeLogger).debug(marker, message); - } - - @Test - void debugFormatArgumentArrayMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.debug(marker, format, argument1, argument2, argument3).block(); - verify(imperativeLogger).debug(marker, format, argument1, argument2, argument3); - } - - @Test - void debugMessageThrowableMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.debug(marker, message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).debug(eq(marker), eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void infoMessage() { - final String message = randomText(); - logger.info(message).block(); - verify(imperativeLogger).info(message); - } - - @Test - void infoFormatArgumentArray() { - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.info(format, argument1, argument2, argument3).block(); - verify(imperativeLogger).info(format, argument1, argument2, argument3); - } - - @Test - void infoMessageThrowable() { - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.info(message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).info(eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void infoMessageMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - logger.info(marker, message).block(); - verify(imperativeLogger).info(marker, message); - } - - @Test - void infoFormatArgumentArrayMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.info(marker, format, argument1, argument2, argument3).block(); - verify(imperativeLogger).info(marker, format, argument1, argument2, argument3); - } - - @Test - void infoMessageThrowableMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.info(marker, message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).info(eq(marker), eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void warnMessage() { - final String message = randomText(); - logger.warn(message).block(); - verify(imperativeLogger).warn(message); - } - - @Test - void warnFormatArgumentArray() { - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.warn(format, argument1, argument2, argument3).block(); - verify(imperativeLogger).warn(format, argument1, argument2, argument3); - } - - @Test - void warnMessageThrowable() { - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.warn(message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).warn(eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void warnMessageMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - logger.warn(marker, message).block(); - verify(imperativeLogger).warn(marker, message); - } - - @Test - void warnFormatArgumentArrayMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.warn(marker, format, argument1, argument2, argument3).block(); - verify(imperativeLogger).warn(marker, format, argument1, argument2, argument3); - } - - @Test - void warnMessageThrowableMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.warn(marker, message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).warn(eq(marker), eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void errorMessage() { - final String message = randomText(); - logger.error(message).block(); - verify(imperativeLogger).error(message); - } - - @Test - void errorFormatArgumentArray() { - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.error(format, argument1, argument2, argument3).block(); - verify(imperativeLogger).error(format, argument1, argument2, argument3); - } - - @Test - void errorMessageThrowable() { - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.error(message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).error(eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void errorMessageMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - logger.error(marker, message).block(); - verify(imperativeLogger).error(marker, message); - } - - @Test - void errorFormatArgumentArrayMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String format = randomText(); - final String argument1 = randomText(); - final String argument2 = randomText(); - final String argument3 = randomText(); - logger.error(marker, format, argument1, argument2, argument3).block(); - verify(imperativeLogger).error(marker, format, argument1, argument2, argument3); - } - - @Test - void errorMessageThrowableMarker() { - final Marker marker = MarkerFactory.getMarker(randomText()); - final String message = randomText(); - final SimulatedException exception = new SimulatedException(randomText()); - logger.error(marker, message, exception).block(); - - final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(SimulatedException.class); - verify(imperativeLogger).error(eq(marker), eq(message), exceptionCaptor.capture()); - assertEquals(exceptionCaptor.getValue().getMessage(), exception.getMessage()); - } - - @Test - void checkEnableErrorFlagDifferent() { - final String message = randomText(); - - Mono process = Mono.defer(() -> loggerWithError.error(message)) - .contextWrite((ctx) -> Context.empty()); - - StepVerifier.create(process).expectError(ContextNotExistException.class).verify(); - } - - public static class SimulatedException extends RuntimeException { - public SimulatedException(final String message) { - super(message); - } - } -} \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/kotlin/MDCContextTest.kt b/src/test/java/io/github/numichi/reactive/logger/kotlin/MDCContextTest.kt deleted file mode 100644 index 8fb30e1..0000000 --- a/src/test/java/io/github/numichi/reactive/logger/kotlin/MDCContextTest.kt +++ /dev/null @@ -1,164 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY -import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.exception.InvalidContextDataException -import io.github.numichi.reactive.logger.kotlin.putMdc -import io.github.numichi.reactive.logger.kotlin.readMDC -import io.github.numichi.reactive.logger.kotlin.withMDCContext -import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.reactor.ReactorContext -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.Test -import org.junit.jupiter.api.assertThrows -import reactor.util.context.Context - -@ExperimentalCoroutinesApi -internal class MDCContextTest { - - companion object { - const val ANOTHER_CONTEXT_KEY = "another-context-key" - } - - @Test - fun `should give the Context with new context maps`() = runTest { - val mdc1 = MDC() - mdc1["mdcKey1"] = "mdcValue1" - val mdc2 = MDC(ANOTHER_CONTEXT_KEY) - mdc2["mdcKey2"] = "mdcValue2" - - val result0 = putMdc(Context.empty()) - assertEquals(0, result0.size()) - - val result1 = putMdc(Context.empty(), mdc1) - assertEquals(mdc1.asMap(), result1.getOrEmpty>(DEFAULT_REACTOR_CONTEXT_MDC_KEY).orElse(null)) - assertEquals(1, result1.size()) - - val result2 = putMdc(Context.empty(), mdc1, mdc2) - assertEquals(mdc1.asMap(), result2.getOrEmpty>(DEFAULT_REACTOR_CONTEXT_MDC_KEY).orElse(null)) - assertEquals(mdc2.asMap(), result2.getOrEmpty>(ANOTHER_CONTEXT_KEY).orElse(null)) - assertEquals(2, result2.size()) - } - - @Test - fun `should give the MDC you are looking for (default key)`() = runTest { - val mdc = MDC() - mdc["mdcKey"] = "mdcValue" - - withMDCContext(mdc) { - val result = readMDC() - assertEquals(mdc, result) - } - - withMDCContext(mdc) { - 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) - assertEquals(mdc, result) - assertEquals(2, size) - } - } - - @Test - fun `should give the MDC you are looking for (default key + use native withContext)`() = runTest { - val mdcMap = mutableMapOf() - mdcMap["mdcKey"] = "mdcValue" - - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to mdcMap)).asCoroutineContext()) { - val result = readMDC(coroutineContext[ReactorContext]?.context) - assertEquals(mdcMap, result) - assertEquals(mdcMap, result.asMap()) - } - } - - @Test - fun `should give the MDC you are looking for (another key)`() = runTest { - val mdc2 = MDC(ANOTHER_CONTEXT_KEY) - mdc2["mdcKey"] = "mdcValue" - - withMDCContext(mdc2) { - val result = readMDC(ANOTHER_CONTEXT_KEY) - assertEquals(mdc2, result) - } - } - - @Test - fun `should give the MDC you are looking for (more MDC Context)`() = runTest { - val mdc1 = MDC() - mdc1["mdcKey"] = "mdcValue" - - val mdc2 = MDC(ANOTHER_CONTEXT_KEY) - mdc2["mdcKey"] = "mdcValue" - - withMDCContext(mdc1, mdc2) { - val result1 = readMDC(coroutineContext[ReactorContext]?.context) - val result2 = readMDC(coroutineContext[ReactorContext]?.context, DEFAULT_REACTOR_CONTEXT_MDC_KEY) - val result3 = readMDC(DEFAULT_REACTOR_CONTEXT_MDC_KEY) - val result4 = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY) - val result5 = readMDC(ANOTHER_CONTEXT_KEY) - - assertEquals(mdc1, result1) - assertEquals(mdc1, result2) - assertEquals(mdc1, result3) - assertEquals(mdc2, result4) - assertEquals(mdc2, result5) - } - } - - @Test - fun `should need to be able to store a map`() = runTest { - val mdcMap = mutableMapOf() - mdcMap["mdcKey"] = "mdcValue" - - withMDCContext(MDC(mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context).asMap() - assertEquals(mdcMap, result) - } - - withMDCContext(MDC(ANOTHER_CONTEXT_KEY, mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY).asMap() - assertEquals(mdcMap, result) - } - } - - @Test - fun `should be MDC stored with the overridden context ID`() = runTest { - val mdcMap = mutableMapOf() - mdcMap["mdcKey"] = "mdcValue" - - withMDCContext(MDC(mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context).asMap() - assertEquals(mdcMap, result) - } - - withMDCContext(MDC(ANOTHER_CONTEXT_KEY, mdcMap)) { - val result = readMDC(coroutineContext[ReactorContext]?.context, ANOTHER_CONTEXT_KEY).asMap() - assertEquals(mdcMap, result) - } - } - - @Test - fun `should throw InvalidContextDataException if context data is invalid`() = runTest { - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to 10)).asCoroutineContext()) { - assertThrows { readMDC() } - } - - withContext(Context.of(mapOf(DEFAULT_REACTOR_CONTEXT_MDC_KEY to "any")).asCoroutineContext()) { - assertThrows { readMDC() } - } - } - - @Test - fun `should throw IllegalArgumentException if any parameter is NULL`() = runTest { - assertThrows { withMDCContext(null, MDC()) {} } - 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/kotlin/ReactiveLoggerTest.kt b/src/test/java/io/github/numichi/reactive/logger/kotlin/ReactiveLoggerTest.kt deleted file mode 100644 index 1f555b7..0000000 --- a/src/test/java/io/github/numichi/reactive/logger/kotlin/ReactiveLoggerTest.kt +++ /dev/null @@ -1,584 +0,0 @@ -package io.github.numichi.reactive.logger.kotlin - -import io.github.numichi.reactive.logger.Values -import io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY -import io.github.numichi.reactive.logger.MDC -import io.github.numichi.reactive.logger.exception.ContextNotExistException -import io.github.numichi.reactive.logger.kotlin.MDCContextTest.Companion.ANOTHER_CONTEXT_KEY -import io.github.numichi.reactive.logger.kotlin.ReactiveLogger -import io.github.numichi.reactive.logger.kotlin.withMDCContext -import io.mockk.clearMocks -import io.mockk.every -import io.mockk.mockk -import io.mockk.slot -import io.mockk.verify -import kotlinx.coroutines.ExperimentalCoroutinesApi -import kotlinx.coroutines.reactor.ReactorContext -import kotlinx.coroutines.test.runTest -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertFalse -import org.junit.jupiter.api.Assertions.assertNotNull -import org.junit.jupiter.api.Assertions.assertSame -import org.junit.jupiter.api.Assertions.assertThrows -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows -import org.slf4j.Logger -import org.slf4j.LoggerFactory -import org.slf4j.Marker -import org.slf4j.MarkerFactory -import reactor.core.scheduler.Schedulers -import reactor.util.context.Context -import java.util.* - -@ExperimentalCoroutinesApi -internal class ReactiveLoggerTest { - private val imperativeLogger: Logger = mockk(relaxed = true) - private val logger = ReactiveLogger.builder().withLogger(imperativeLogger).build() - private val loggerScheduled = ReactiveLogger.builder().withScheduler(Schedulers.parallel()).withLogger(imperativeLogger).build() - private val loggerWithError = ReactiveLogger.builder().withLogger(imperativeLogger).enableError().build() - - companion object { - @JvmStatic - fun randomText(): String { - return UUID.randomUUID().toString() - } - - @JvmStatic - fun randomMap(i: Int): MutableMap { - var index = i - val expected: MutableMap = HashMap() - while (0 < index) { - expected[randomText()] = randomText() - index-- - } - return expected - } - } - - @BeforeEach - fun beforeEach() { - clearMocks(imperativeLogger) - } - - @Test - fun contextExtractiveOfReactiveLogger() = runTest { - assertThrows { - ReactiveLogger.builder(ReactorContext).withLogger(imperativeLogger).build().info("") - } - - assertThrows { - ReactiveLogger.builder(ReactorContext).withContext { null }.withLogger(imperativeLogger).build().info("") - } - } - - @Test - fun snapshot() = runTest { - val mdc = MDC() - mdc[randomText()] = randomText() - var context1 = Context.empty() - context1 = context1.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc.asMap()) - var context2 = Context.empty() - context2 = context2.put(ANOTHER_CONTEXT_KEY, mdc.asMap()) - - var mdcResult = logger.snapshot(context1) - assertEquals(mdc.asMap(), mdcResult?.asMap()) - - mdcResult = logger.snapshot(context2) - assertEquals(mapOf(), mdcResult?.asMap()) - - assertThrows { - loggerWithError.snapshot(null) - } - - withMDCContext(context1) { - mdcResult = logger.snapshot(null) - assertEquals(mdc.asMap(), mdcResult?.asMap()) - } - - withMDCContext(context2) { - mdcResult = logger.snapshot(null) - assertEquals(mapOf(), logger.snapshot()) - } - - withMDCContext(context1) { - mdcResult = logger.snapshot() - assertEquals(mdc.asMap(), mdcResult?.asMap()) - } - - withMDCContext(context2) { - mdcResult = logger.snapshot() - assertEquals(mapOf(), logger.snapshot()) - } - } - - @Test - fun builderWithClassLogger() { - assertNotNull(ReactiveLogger.builder().withLogger(this.javaClass).build()) - assertNotNull(ReactiveLogger.builder().withLogger("any").build()) - assertNotNull(ReactiveLogger.builder().withLogger(LoggerFactory.getLogger(this.javaClass)).build()) - } - - @Test - fun getName() { - val name: String = randomText() - every { imperativeLogger.name } returns name - assertEquals(name, logger.name) - } - - @Test - fun readMDC() { - val mdc: Map = randomMap(1) - val context = Context.of(Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc) - assertEquals(Optional.of(mdc), logger.readMDC(context)) - assertEquals(Optional.of(mdc).get(), logger.readMDC(context).get()) - } - - @Test - fun imperative() { - assertSame(logger.imperative, imperativeLogger) - assertSame(loggerWithError.imperative, imperativeLogger) - } - - @Test - fun scheduled() { - assertSame(Schedulers.boundedElastic(), logger.scheduler) - assertSame(Schedulers.parallel(), loggerScheduled.scheduler) - } - - @Test - fun contextKey() { - val contextKey = "another-context-key" - val loggerWithCustomScheduler = ReactiveLogger.builder().withMDCContextKey(contextKey).build() - - assertSame(loggerWithCustomScheduler.mdcContextKey, contextKey) - - assertThrows(IllegalArgumentException::class.java) { - ReactiveLogger.builder().withMDCContextKey("").build() - } - - assertThrows(IllegalArgumentException::class.java) { - ReactiveLogger.builder().withMDCContextKey(" ").build() - } - } - - @Test - fun traceEnabled() { - every { imperativeLogger.isTraceEnabled } returnsMany listOf(true, false, true) - assertTrue(logger.isTraceEnabled, "trace not enabled when it should be") - assertFalse(logger.isTraceEnabled, "trace enabled when it should not be") - assertTrue(logger.isTraceEnabled, "trace not enabled when it should be") - } - - @Test - fun traceEnabledMarker() { - val marker = MarkerFactory.getMarker(randomText()) - every { imperativeLogger.isTraceEnabled(marker) } returnsMany listOf(true, false, true) - assertTrue(logger.isTraceEnabled(marker), "trace not enabled when it should be") - assertFalse(logger.isTraceEnabled(marker), "trace enabled when it should not be") - assertTrue(logger.isTraceEnabled(marker), "trace not enabled when it should be") - } - - @Test - fun debugEnabled() { - every { imperativeLogger.isDebugEnabled } returnsMany listOf(true, false, true) - assertTrue(logger.isDebugEnabled, "debug not enabled when it should be") - assertFalse(logger.isDebugEnabled, "debug enabled when it should not be") - assertTrue(logger.isDebugEnabled, "debug not enabled when it should be") - } - - @Test - fun debugEnabledMarker() { - val marker = MarkerFactory.getMarker(randomText()) - every { imperativeLogger.isDebugEnabled(marker) } returnsMany listOf(true, false, true) - assertTrue(logger.isDebugEnabled(marker), "debug not enabled when it should be") - assertFalse(logger.isDebugEnabled(marker), "debug enabled when it should not be") - assertTrue(logger.isDebugEnabled(marker), "debug not enabled when it should be") - } - - @Test - fun infoEnabled() { - every { imperativeLogger.isInfoEnabled } returnsMany listOf(true, false, true) - assertTrue(logger.isInfoEnabled, "info not enabled when it should be") - assertFalse(logger.isInfoEnabled, "info enabled when it should not be") - assertTrue(logger.isInfoEnabled, "info not enabled when it should be") - } - - @Test - fun infoEnabledMarker() { - val marker = MarkerFactory.getMarker(randomText()) - every { imperativeLogger.isInfoEnabled(marker) } returnsMany listOf(true, false, true) - assertTrue(logger.isInfoEnabled(marker), "info not enabled when it should be") - assertFalse(logger.isInfoEnabled(marker), "info enabled when it should not be") - assertTrue(logger.isInfoEnabled(marker), "info not enabled when it should be") - } - - @Test - fun warnEnabled() { - every { imperativeLogger.isWarnEnabled } returnsMany listOf(true, false, true) - assertTrue(logger.isWarnEnabled, "warn not enabled when it should be") - assertFalse(logger.isWarnEnabled, "warn enabled when it should not be") - assertTrue(logger.isWarnEnabled, "warn not enabled when it should be") - } - - @Test - fun warnEnabledMarker() { - val marker = MarkerFactory.getMarker(randomText()) - every { imperativeLogger.isWarnEnabled(marker) } returnsMany listOf(true, false, true) - assertTrue(logger.isWarnEnabled(marker), "warn not enabled when it should be") - assertFalse(logger.isWarnEnabled(marker), "warn enabled when it should not be") - assertTrue(logger.isWarnEnabled(marker), "warn not enabled when it should be") - } - - @Test - fun errorEnabled() { - every { imperativeLogger.isErrorEnabled } returnsMany listOf(true, false, true) - assertTrue(logger.isErrorEnabled, "error not enabled when it should be") - assertFalse(logger.isErrorEnabled, "error enabled when it should not be") - assertTrue(logger.isErrorEnabled, "error not enabled when it should be") - } - - @Test - fun errorEnabledMarker() { - val marker = MarkerFactory.getMarker(randomText()) - every { imperativeLogger.isErrorEnabled(marker) } returnsMany listOf(true, false, true) - assertTrue(logger.isErrorEnabled(marker), "error not enabled when it should be") - assertFalse(logger.isErrorEnabled(marker), "error enabled when it should not be") - assertTrue(logger.isErrorEnabled(marker), "error not enabled when it should be") - } - - //region Trace - @Test - fun traceMessage() = runTest { - val message: String = randomText() - logger.trace(message) - verify { imperativeLogger.trace(message) } - } - - @Test - fun traceFormatArgumentArray() = runTest { - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.trace(format, argument1, argument2, argument3) - verify { imperativeLogger.trace(format, argument1, argument2, argument3) } - } - - @Test - fun traceMessageThrowable() = runTest { - val message: String = randomText() - val exception = SimulatedException(randomText()) - val exceptionCaptor = slot() - val stringCaptor = slot() - every { imperativeLogger.trace(capture(stringCaptor), capture(exceptionCaptor)) } returns Unit - logger.trace(message, exception) - assertEquals(exceptionCaptor.captured.message, exception.message) - assertEquals(stringCaptor.captured, message) - } - - @Test - fun traceMessageMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - logger.trace(marker, message) - verify { imperativeLogger.trace(marker, message) } - } - - @Test - fun traceFormatArgumentArrayMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.trace(marker, format, argument1, argument2, argument3) - verify { imperativeLogger.trace(marker, format, argument1, argument2, argument3) } - } - - @Test - fun traceMessageThrowableMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - val exception = SimulatedException(randomText()) - val markerCaptor = slot() - val messageCaptor = slot() - val exceptionCaptor = slot() - every { imperativeLogger.trace(capture(markerCaptor), capture(messageCaptor), capture(exceptionCaptor)) } returns Unit - logger.trace(marker, message, exception) - assertEquals(markerCaptor.captured, marker) - assertEquals(messageCaptor.captured, message) - assertEquals(exceptionCaptor.captured, exception) - } - //endregion - - //region Debug - @Test - fun debugMessage() = runTest { - val message: String = randomText() - logger.debug(message) - verify { imperativeLogger.debug(message) } - } - - @Test - fun debugFormatArgumentArray() = runTest { - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.debug(format, argument1, argument2, argument3) - verify { imperativeLogger.debug(format, argument1, argument2, argument3) } - } - - @Test - fun debugMessageThrowable() = runTest { - val message: String = randomText() - val exception = SimulatedException(randomText()) - val exceptionCaptor = slot() - val stringCaptor = slot() - every { imperativeLogger.debug(capture(stringCaptor), capture(exceptionCaptor)) } returns Unit - logger.debug(message, exception) - assertEquals(exceptionCaptor.captured.message, exception.message) - assertEquals(stringCaptor.captured, message) - } - - @Test - fun debugMessageMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - logger.debug(marker, message) - verify { imperativeLogger.debug(marker, message) } - } - - @Test - fun debugFormatArgumentArrayMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.debug(marker, format, argument1, argument2, argument3) - verify { imperativeLogger.debug(marker, format, argument1, argument2, argument3) } - } - - @Test - fun debugMessageThrowableMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - val exception = SimulatedException(randomText()) - val markerCaptor = slot() - val messageCaptor = slot() - val exceptionCaptor = slot() - every { imperativeLogger.debug(capture(markerCaptor), capture(messageCaptor), capture(exceptionCaptor)) } returns Unit - logger.debug(marker, message, exception) - assertEquals(markerCaptor.captured, marker) - assertEquals(messageCaptor.captured, message) - assertEquals(exceptionCaptor.captured, exception) - } - //endregion - - //region Info - @Test - fun infoMessage() = runTest { - val message: String = randomText() - logger.info(message) - verify { imperativeLogger.info(message) } - } - - @Test - fun infoFormatArgumentArray() = runTest { - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.info(format, argument1, argument2, argument3) - verify { imperativeLogger.info(format, argument1, argument2, argument3) } - } - - @Test - fun infoMessageThrowable() = runTest { - val message: String = randomText() - val exception = SimulatedException(randomText()) - val exceptionCaptor = slot() - val stringCaptor = slot() - every { imperativeLogger.info(capture(stringCaptor), capture(exceptionCaptor)) } returns Unit - logger.info(message, exception) - assertEquals(exceptionCaptor.captured.message, exception.message) - assertEquals(stringCaptor.captured, message) - } - - @Test - fun infoMessageMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - logger.info(marker, message) - verify { imperativeLogger.info(marker, message) } - } - - @Test - fun infoFormatArgumentArrayMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.info(marker, format, argument1, argument2, argument3) - verify { imperativeLogger.info(marker, format, argument1, argument2, argument3) } - } - - @Test - fun infoMessageThrowableMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - val exception = SimulatedException(randomText()) - val markerCaptor = slot() - val messageCaptor = slot() - val exceptionCaptor = slot() - every { imperativeLogger.info(capture(markerCaptor), capture(messageCaptor), capture(exceptionCaptor)) } returns Unit - logger.info(marker, message, exception) - assertEquals(markerCaptor.captured, marker) - assertEquals(messageCaptor.captured, message) - assertEquals(exceptionCaptor.captured, exception) - } - //endregion - - //region Warn - @Test - fun warnMessage() = runTest { - val message: String = randomText() - logger.warn(message) - verify { imperativeLogger.warn(message) } - } - - @Test - fun warnFormatArgumentArray() = runTest { - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.warn(format, argument1, argument2, argument3) - verify { imperativeLogger.warn(format, argument1, argument2, argument3) } - } - - @Test - fun warnMessageThrowable() = runTest { - val message: String = randomText() - val exception = SimulatedException(randomText()) - val exceptionCaptor = slot() - val stringCaptor = slot() - every { imperativeLogger.warn(capture(stringCaptor), capture(exceptionCaptor)) } returns Unit - logger.warn(message, exception) - assertEquals(exceptionCaptor.captured.message, exception.message) - assertEquals(stringCaptor.captured, message) - } - - @Test - fun warnMessageMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - logger.warn(marker, message) - verify { imperativeLogger.warn(marker, message) } - } - - @Test - fun warnFormatArgumentArrayMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.warn(marker, format, argument1, argument2, argument3) - verify { imperativeLogger.warn(marker, format, argument1, argument2, argument3) } - } - - @Test - fun warnMessageThrowableMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - val exception = SimulatedException(randomText()) - val markerCaptor = slot() - val messageCaptor = slot() - val exceptionCaptor = slot() - every { imperativeLogger.warn(capture(markerCaptor), capture(messageCaptor), capture(exceptionCaptor)) } returns Unit - logger.warn(marker, message, exception) - assertEquals(markerCaptor.captured, marker) - assertEquals(messageCaptor.captured, message) - assertEquals(exceptionCaptor.captured, exception) - } - //endregion - - //region Error - @Test - fun errorMessage() = runTest { - val message: String = randomText() - logger.error(message) - verify { imperativeLogger.error(message) } - } - - @Test - fun errorFormatArgumentArray() = runTest { - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.error(format, argument1, argument2, argument3) - verify { imperativeLogger.error(format, argument1, argument2, argument3) } - } - - @Test - fun errorMessageThrowable() = runTest { - val message: String = randomText() - val exception = SimulatedException(randomText()) - val exceptionCaptor = slot() - val stringCaptor = slot() - every { imperativeLogger.error(capture(stringCaptor), capture(exceptionCaptor)) } returns Unit - logger.error(message, exception) - assertEquals(exceptionCaptor.captured.message, exception.message) - assertEquals(stringCaptor.captured, message) - } - - @Test - fun errorMessageMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - logger.error(marker, message) - verify { imperativeLogger.error(marker, message) } - } - - @Test - fun errorFormatArgumentArrayMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val format: String = randomText() - val argument1: String = randomText() - val argument2: String = randomText() - val argument3: String = randomText() - logger.error(marker, format, argument1, argument2, argument3) - verify { imperativeLogger.error(marker, format, argument1, argument2, argument3) } - } - - @Test - fun errorMessageThrowableMarker() = runTest { - val marker = MarkerFactory.getMarker(randomText()) - val message: String = randomText() - val exception = SimulatedException(randomText()) - val markerCaptor = slot() - val messageCaptor = slot() - val exceptionCaptor = slot() - every { imperativeLogger.error(capture(markerCaptor), capture(messageCaptor), capture(exceptionCaptor)) } returns Unit - logger.error(marker, message, exception) - assertEquals(markerCaptor.captured, marker) - assertEquals(messageCaptor.captured, message) - assertEquals(exceptionCaptor.captured, exception) - } - //endregion - - @Test - fun checkEnableErrorFlagDifferent() = runTest { - assertThrows { - loggerWithError.info(randomText()) - } - } - - class SimulatedException(message: String?) : RuntimeException(message) -} \ No newline at end of file diff --git a/src/test/java/io/github/numichi/reactive/logger/reactor/MDCContextTest.java b/src/test/java/io/github/numichi/reactive/logger/reactor/MDCContextTest.java index 8af61b5..fdc80f5 100644 --- a/src/test/java/io/github/numichi/reactive/logger/reactor/MDCContextTest.java +++ b/src/test/java/io/github/numichi/reactive/logger/reactor/MDCContextTest.java @@ -1,15 +1,14 @@ package io.github.numichi.reactive.logger.reactor; +import io.github.numichi.reactive.logger.DefaultValues; import io.github.numichi.reactive.logger.MDC; import io.github.numichi.reactive.logger.exception.InvalidContextDataException; -import io.github.numichi.reactive.logger.java.MDCContext; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; import reactor.util.context.Context; -import static io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; import static org.junit.jupiter.api.Assertions.assertThrows; class MDCContextTest { @@ -145,7 +144,7 @@ void shouldThrowIllegalArgumentExceptionTest() { @Test @DisplayName("should throw InvalidContextDataException if context data is invalid") void shouldThrowInvalidContextDataException() { - // ANOTHER_CONTEXT_KEY is not DEFAULT_REACTOR_CONTEXT_MDC_KEY + // ANOTHER_CONTEXT_KEY is not DefaultValues.getInstance().getDefaultReactorContextMdcKey() MDC mdc = new MDC(ANOTHER_CONTEXT_KEY); mdc.put("mdcKey2", "mdcValue2"); Mono result1 = Mono.defer(MDCContext::read) @@ -163,14 +162,14 @@ void shouldThrowInvalidContextDataException() { Mono result3 = Mono.defer(MDCContext::read) - .contextWrite(it -> it.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, "")); + .contextWrite(it -> it.put(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), "")); StepVerifier.create(result3) .expectError(InvalidContextDataException.class) .verify(); Mono result4 = Mono.defer(MDCContext::read) - .contextWrite(it -> it.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, 100)); + .contextWrite(it -> it.put(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), 100)); StepVerifier.create(result4) .expectError(InvalidContextDataException.class) .verify(); diff --git a/src/test/java/io/github/numichi/reactive/logger/reactor/MDCSnapshotTest.java b/src/test/java/io/github/numichi/reactive/logger/reactor/MDCSnapshotTest.java index 8443478..2666661 100644 --- a/src/test/java/io/github/numichi/reactive/logger/reactor/MDCSnapshotTest.java +++ b/src/test/java/io/github/numichi/reactive/logger/reactor/MDCSnapshotTest.java @@ -1,6 +1,5 @@ package io.github.numichi.reactive.logger.reactor; -import io.github.numichi.reactive.logger.java.MDCSnapshot; import org.junit.jupiter.api.Test; import org.slf4j.MDC; diff --git a/src/test/java/io/github/numichi/reactive/logger/reactor/ReactiveLoggerTest.java b/src/test/java/io/github/numichi/reactive/logger/reactor/ReactiveLoggerTest.java index df93581..c2f89c9 100644 --- a/src/test/java/io/github/numichi/reactive/logger/reactor/ReactiveLoggerTest.java +++ b/src/test/java/io/github/numichi/reactive/logger/reactor/ReactiveLoggerTest.java @@ -1,5 +1,6 @@ package io.github.numichi.reactive.logger.reactor; +import io.github.numichi.reactive.logger.DefaultValues; import io.github.numichi.reactive.logger.MDC; import io.github.numichi.reactive.logger.exception.ContextNotExistException; import org.junit.jupiter.api.BeforeEach; @@ -21,7 +22,6 @@ import java.util.Optional; import java.util.UUID; -import static io.github.numichi.reactive.logger.Values.DEFAULT_REACTOR_CONTEXT_MDC_KEY; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -83,7 +83,7 @@ void getName() { @Test void readMDC() { final Map mdc = randomMap(1); - final Context context = Context.of(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc); + final Context context = Context.of(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc); assertEquals(Optional.of(mdc), logger.readMDC(context)); assertEquals(Optional.of(mdc).get(), logger.readMDC(context).get()); } @@ -91,7 +91,7 @@ void readMDC() { @Test void takeMDCSnapshot() { final Map mdc = randomMap(1); - final Context context = Context.of(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc); + final Context context = Context.of(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc); try (final MDCSnapshot snapshot = logger.takeMDCSnapshot(context)) { assertEquals(org.slf4j.MDC.getCopyOfContextMap(), mdc); } @@ -109,7 +109,7 @@ void snapshot() { mdc.put(randomText(), randomText()); Context context1 = Context.empty(); - context1 = context1.put(DEFAULT_REACTOR_CONTEXT_MDC_KEY, mdc.asMap()); + context1 = context1.put(DefaultValues.getInstance().getDefaultReactorContextMdcKey(), mdc.asMap()); Mono snapshot1 = logger.snapshot(context1); StepVerifier.create(snapshot1) .expectNextMatches(mdc1 -> mdc1.asMap().equals(mdc.asMap()))