refine tests

Author: trask

sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java

@@ -11,6 +11,9 @@
 import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import io.opentelemetry.api.common.AttributeKey;
@@ -124,75 +127,23 @@ void emit_NoFields() {
   }
 
   @Test
-  void emit_WithMinimumSeverityConfiguration() {
-    LoggerConfig config =
-        LoggerConfig.builder().setMinimumSeverity(Severity.INFO.getSeverityNumber()).build();
-    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
+  void emit_ChecksLoggerIsEnabled() {
+    SdkLogger logger = mock(SdkLogger.class);
     builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
 
-    builder.setBody("too-low").setSeverity(Severity.DEBUG).emit();
-    assertThat(emittedLog.get()).isNull();
-
-    builder.setBody("allowed").setSeverity(Severity.INFO).emit();
-    assertThat(emittedLog.get().toLogRecordData()).hasBody("allowed");
-  }
-
-  @Test
-  void emit_DropsUnsampledTraceWhenTraceBased() {
-    LoggerConfig config = LoggerConfig.builder().setTraceBased(true).build();
-    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
-    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
-
-    SpanContext unsampledSpanContext =
-        SpanContext.create(
-            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-            "bbbbbbbbbbbbbbbb",
-            TraceFlags.getDefault(),
-            TraceState.getDefault());
-    builder
-        .setBody("unsampled")
-        .setContext(Span.wrap(unsampledSpanContext).storeInContext(Context.root()))
-        .emit();
-    assertThat(emittedLog.get()).isNull();
-
-    SpanContext sampledSpanContext =
-        SpanContext.create(
-            "cccccccccccccccccccccccccccccccc",
-            "dddddddddddddddd",
-            TraceFlags.getSampled(),
-            TraceState.getDefault());
-    builder
-        .setBody("sampled")
-        .setContext(Span.wrap(sampledSpanContext).storeInContext(Context.root()))
-        .emit();
-    assertThat(emittedLog.get().toLogRecordData())
-        .hasSpanContext(sampledSpanContext)
-        .hasBody("sampled");
-  }
+    Severity severity = Severity.WARN;
+    Context context = Context.current();
 
-  @Test
-  void emit_AllowsUndefinedSeverityWithMinimumSeverity() {
-    LoggerConfig config =
-        LoggerConfig.builder().setMinimumSeverity(Severity.WARN.getSeverityNumber()).build();
-    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
-    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
+    // Configure mock to return false (disabled)
+    when(logger.isEnabled(severity, context)).thenReturn(false);
 
-    // Undefined severity should bypass the minimum severity filter
-    builder.setBody("undefined-severity").setSeverity(Severity.UNDEFINED_SEVERITY_NUMBER).emit();
-    assertThat(emittedLog.get().toLogRecordData())
-        .hasBody("undefined-severity")
-        .hasSeverity(Severity.UNDEFINED_SEVERITY_NUMBER);
-  }
+    builder.setSeverity(severity).setContext(context).emit();
 
-  @Test
-  void emit_AllowsNoTraceContextWithTraceBased() {
-    LoggerConfig config = LoggerConfig.builder().setTraceBased(true).build();
-    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
-    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
+    // Verify isEnabled was called with correct parameters
+    verify(logger).isEnabled(eq(severity), eq(context));
 
-    // No trace context should bypass the trace-based filter
-    builder.setBody("no-trace-context").emit();
-    assertThat(emittedLog.get().toLogRecordData()).hasBody("no-trace-context");
+    // Verify log was not processed (because isEnabled returned false)
+    assertThat(emittedLog.get()).isNull();
   }
 
   @Test

sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLoggerTest.java

@@ -141,20 +141,7 @@ void logRecordBuilder_AfterShutdown() {
   }
 
   @Test
-  void updateEnabled() {
-    LogRecordProcessor logRecordProcessor = mock(LogRecordProcessor.class);
-    SdkLoggerProvider loggerProvider =
-        SdkLoggerProvider.builder().addLogRecordProcessor(logRecordProcessor).build();
-    SdkLogger logger = (SdkLogger) loggerProvider.get("test");
-
-    logger.updateLoggerConfig(LoggerConfig.disabled());
-    assertThat(logger.isEnabled(Severity.UNDEFINED_SEVERITY_NUMBER, Context.current())).isFalse();
-    logger.updateLoggerConfig(LoggerConfig.enabled());
-    assertThat(logger.isEnabled(Severity.UNDEFINED_SEVERITY_NUMBER, Context.current())).isTrue();
-  }
-
-  @Test
-  void updateLoggerConfig_UpdatesAllFields() {
+  void updateLoggerConfig() {
     LogRecordProcessor logRecordProcessor = mock(LogRecordProcessor.class);
     SdkLoggerProvider loggerProvider =
         SdkLoggerProvider.builder().addLogRecordProcessor(logRecordProcessor).build();
@@ -235,46 +222,4 @@ void isEnabled_TraceBased() {
     Context unsampledContext = Span.wrap(unsampledSpanContext).storeInContext(Context.root());
     assertThat(logger.isEnabled(Severity.INFO, unsampledContext)).isFalse();
   }
-
-  @Test
-  void isEnabled_MinimumSeverityAndTraceBased() {
-    LogRecordProcessor logRecordProcessor = mock(LogRecordProcessor.class);
-    SdkLoggerProvider loggerProvider =
-        SdkLoggerProvider.builder().addLogRecordProcessor(logRecordProcessor).build();
-    SdkLogger logger = (SdkLogger) loggerProvider.get("test");
-
-    LoggerConfig config =
-        LoggerConfig.builder()
-            .setMinimumSeverity(Severity.WARN.getSeverityNumber())
-            .setTraceBased(true)
-            .build();
-    logger.updateLoggerConfig(config);
-
-    SpanContext sampledSpanContext =
-        SpanContext.create(
-            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-            "bbbbbbbbbbbbbbbb",
-            TraceFlags.getSampled(),
-            TraceState.getDefault());
-    Context sampledContext = Span.wrap(sampledSpanContext).storeInContext(Context.root());
-
-    SpanContext unsampledSpanContext =
-        SpanContext.create(
-            "cccccccccccccccccccccccccccccccc",
-            "dddddddddddddddd",
-            TraceFlags.getDefault(),
-            TraceState.getDefault());
-    Context unsampledContext = Span.wrap(unsampledSpanContext).storeInContext(Context.root());
-
-    // Below minimum severity in sampled trace - should be disabled
-    assertThat(logger.isEnabled(Severity.INFO, sampledContext)).isFalse();
-
-    // At or above minimum severity in sampled trace - should be enabled
-    assertThat(logger.isEnabled(Severity.WARN, sampledContext)).isTrue();
-    assertThat(logger.isEnabled(Severity.ERROR, sampledContext)).isTrue();
-
-    // At or above minimum severity in unsampled trace - should be disabled
-    assertThat(logger.isEnabled(Severity.WARN, unsampledContext)).isFalse();
-    assertThat(logger.isEnabled(Severity.ERROR, unsampledContext)).isFalse();
-  }
 }