Use assertJ in tests (#876)

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/TracerAutoConfigurationTest.java

@@ -16,12 +16,11 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 import io.opentelemetry.OpenTelemetry;
 import io.opentelemetry.trace.Tracer;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.TestConfiguration;
@@ -29,7 +28,7 @@ import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 
 /** Spring Boot auto configuration test for {@link TracerAutoConfiguration} */
-public class TracerAutoConfigurationTest {
+class TracerAutoConfigurationTest {
   @TestConfiguration
   static class CustomTracerConfiguration {
     @Bean
@@ -41,45 +40,39 @@ public class TracerAutoConfigurationTest {
   private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
 
   @Test
-  public void should_NOT_initalize_otelTracer_if_tracer_bean_exists() {
+  @DisplayName("when Application Context contains Tracer bean should NOT initalize otelTracer")
+  void customTracer() {
     this.contextRunner
         .withUserConfiguration(CustomTracerConfiguration.class)
         .withConfiguration(AutoConfigurations.of(TracerAutoConfiguration.class))
         .run(
             (context) -> {
-              assertTrue(
+              assertThat(context.containsBean("customTestTracer")).isTrue();
-                  "Application Context contains customTestTracer bean",
+              assertThat(context.containsBean("otelTracer")).isFalse();
-                  context.containsBean("customTestTracer"));
-
-              assertFalse(
-                  "Application Context DOES NOT contain the otelTracer bean defined in TracerAutoConfiguration",
-                  context.containsBean("otelTracer"));
             });
   }
 
   @Test
-  public void should_contain_otelTracer_bean() {
+  @DisplayName("when Application Context DOES NOT contain Tracer bean should initialize otelTracer")
+  void initalizeTracer() {
     this.contextRunner
         .withConfiguration(AutoConfigurations.of(TracerAutoConfiguration.class))
         .run(
             (context) -> {
-              assertTrue(
+              assertThat(context.containsBean("otelTracer")).isTrue();
-                  "Application Context contains otelTracer bean",
-                  context.containsBean("otelTracer"));
             });
   }
 
   @Test
-  public void should_set_tracer_name() {
+  @DisplayName("when opentelemetry.trace.tracer.name is set should initialize tracer with name")
+  void withTracerNameProperty() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.tracer.name=testTracer")
         .withConfiguration(AutoConfigurations.of(TracerAutoConfiguration.class))
         .run(
             (context) -> {
-              assertEquals(
+              assertThat(context.getBean("otelTracer", Tracer.class))
-                  "Application Context sets the Tracer with name to testTracer",
+                  .isEqualTo(OpenTelemetry.getTracer("testTracer"));
-                  context.getBean("otelTracer", Tracer.class),
-                  OpenTelemetry.getTracer("testTracer"));
             });
   }
 }

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/httpclients/resttemplate/RestTemplateAutoConfigurationTest.java

@@ -16,16 +16,16 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.httpclients.resttemplate;
 
-import static org.junit.Assert.assertFalse;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
 
 import io.opentelemetry.instrumentation.spring.autoconfigure.TracerAutoConfiguration;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 
 /** Spring Boot auto configuration test for {@link RestTemplateAutoConfiguration} */
-public class RestTemplateAutoConfigurationTest {
+class RestTemplateAutoConfigurationTest {
 
   private final ApplicationContextRunner contextRunner =
       new ApplicationContextRunner()
@@ -34,39 +34,40 @@ public class RestTemplateAutoConfigurationTest {
                   TracerAutoConfiguration.class, RestTemplateAutoConfiguration.class));
 
   @Test
-  public void should_initialize_RestTemplateInterceptor_bean_when_httpclients_are_ENABLED() {
+  @DisplayName("when httpclients are ENABLED should initialize RestTemplateInterceptor bean")
+  void httpClientsEnabled() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.httpclients.enabled=true")
         .run(
             (context) -> {
-              assertNotNull(
+              assertThat(
-                  "Application Context contains RestTemplateBeanPostProcessor bean",
+                      context.getBean(
-                  context.getBean(
+                          "otelRestTemplateBeanPostProcessor", RestTemplateBeanPostProcessor.class))
-                      "otelRestTemplateBeanPostProcessor", RestTemplateBeanPostProcessor.class));
+                  .isNotNull();
             });
   }
 
   @Test
-  public void should_NOT_initialize_RestTemplateInterceptor_bean_when_httpclients_are_DISABLED() {
+  @DisplayName("when httpclients are DISABLED should NOT initialize RestTemplateInterceptor bean")
+  void disabledProperty() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.httpclients.enabled=false")
         .run(
             (context) -> {
-              assertFalse(
+              assertThat(context.containsBean("otelRestTemplateBeanPostProcessor")).isFalse();
-                  "Application Context DOES NOT contain otelRestTemplateBeanPostProcessor bean",
-                  context.containsBean("otelRestTemplateBeanPostProcessor"));
             });
   }
 
   @Test
-  public void
+  @DisplayName(
-      should_initialize_RestTemplateInterceptor_bean_when_httpclients_enabled_property_is_MISSING() {
+      "when httpclients enabled property is MISSING should initialize RestTemplateInterceptor bean")
+  void noProperty() {
     this.contextRunner.run(
         (context) -> {
-          assertNotNull(
+          assertThat(
-              "Application Context contains RestTemplateBeanPostProcessor bean",
+                  context.getBean(
-              context.getBean(
+                      "otelRestTemplateBeanPostProcessor", RestTemplateBeanPostProcessor.class))
-                  "otelRestTemplateBeanPostProcessor", RestTemplateBeanPostProcessor.class));
+              .isNotNull();
         });
   }
 }

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/httpclients/resttemplate/RestTemplateBeanPostProcessorTest.java

@@ -16,12 +16,12 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.httpclients.resttemplate;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
 
 import io.opentelemetry.instrumentation.spring.httpclients.RestTemplateInterceptor;
 import io.opentelemetry.trace.Tracer;
 import org.junit.Test;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -29,42 +29,43 @@ import org.springframework.web.client.RestTemplate;
 
 /** Spring bean post processor test {@link RestTemplateBeanPostProcessor} */
 @RunWith(MockitoJUnitRunner.class)
-public class RestTemplateBeanPostProcessorTest {
+class RestTemplateBeanPostProcessorTest {
-
   @Mock Tracer tracer;
 
   RestTemplateBeanPostProcessor restTemplateBeanPostProcessor =
       new RestTemplateBeanPostProcessor(tracer);
 
   @Test
-  public void should_return_object_if_processed_bean_is_not_of_type_RestTemplate() {
+  @DisplayName("when processed bean is not of type RestTemplate should return object")
-    assertEquals(
+  void returnsObject() {
-        restTemplateBeanPostProcessor
+    assertThat(
-            .postProcessAfterInitialization(new Object(), "testObject")
+            restTemplateBeanPostProcessor.postProcessAfterInitialization(
-            .getClass(),
+                new Object(), "testObject"))
-        Object.class);
+        .isExactlyInstanceOf(Object.class);
   }
 
   @Test
-  public void should_return_RestTemplate_if_processed_bean_is_of_type_RestTemplate() {
+  @DisplayName("when processed bean is of type RestTemplate should return RestTemplate")
-    assertTrue(
+  void returnsRestTemplate() {
-        restTemplateBeanPostProcessor.postProcessAfterInitialization(
+    assertThat(
-                new RestTemplate(), "testRestTemplate")
+            restTemplateBeanPostProcessor.postProcessAfterInitialization(
-            instanceof RestTemplate);
+                new RestTemplate(), "testRestTemplate"))
+        .isInstanceOf(RestTemplate.class);
   }
 
   @Test
-  public void should_add_ONE_RestTemplateInterceptor_if_processed_bean_is_of_type_RestTemplate() {
+  @DisplayName("when processed bean is of type RestTemplate should add ONE RestTemplateInterceptor")
+  void addsRestTemplateInterceptor() {
     RestTemplate restTemplate = new RestTemplate();
 
     restTemplateBeanPostProcessor.postProcessAfterInitialization(restTemplate, "testRestTemplate");
     restTemplateBeanPostProcessor.postProcessAfterInitialization(restTemplate, "testRestTemplate");
     restTemplateBeanPostProcessor.postProcessAfterInitialization(restTemplate, "testRestTemplate");
 
-    assertEquals(
+    assertThat(
-        restTemplate.getInterceptors().stream()
+            restTemplate.getInterceptors().stream()
-            .filter(rti -> rti instanceof RestTemplateInterceptor)
+                .filter(rti -> rti instanceof RestTemplateInterceptor)
-            .count(),
+                .count())
-        1);
+        .isEqualTo(1);
   }
 }

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/httpclients/webclient/WebClientAutoConfigurationTest.java

@@ -16,16 +16,16 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.httpclients.webclient;
 
-import static org.junit.Assert.assertFalse;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
 
 import io.opentelemetry.instrumentation.spring.autoconfigure.TracerAutoConfiguration;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 
 /** Spring Boot auto configuration test for {@link WebClientAutoConfiguration} */
-public class WebClientAutoConfigurationTest {
+class WebClientAutoConfigurationTest {
 
   private final ApplicationContextRunner contextRunner =
       new ApplicationContextRunner()
@@ -34,39 +34,41 @@ public class WebClientAutoConfigurationTest {
                   TracerAutoConfiguration.class, WebClientAutoConfiguration.class));
 
   @Test
-  public void should_initialize_WebClientBeanPostProccesor_bean_when_httpclients_are_ENABLED() {
+  @DisplayName("when httpclients are ENABLED should initialize WebClientBeanPostProccesor bean")
+  void httpClientsEnabled() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.httpclients.enabled=true")
         .run(
             (context) -> {
-              assertNotNull(
+              assertThat(
-                  "Application Context contains WebClientBeanPostProcessor bean",
+                      context.getBean(
-                  context.getBean(
+                          "otelWebClientBeanPostProcessor", WebClientBeanPostProcessor.class))
-                      "otelWebClientBeanPostProcessor", WebClientBeanPostProcessor.class));
+                  .isNotNull();
             });
   }
 
   @Test
-  public void
+  @DisplayName(
-      should_NOT_initialize_WebClientBeanPostProccesor_bean_when_httpclients_are_DISABLED() {
+      "when httpclients are DISABLED should NOT initialize WebClientBeanPostProccesor bean")
+  void disabledProperty() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.httpclients.enabled=false")
         .run(
             (context) -> {
-              assertFalse(
+              assertThat(context.containsBean("otelWebClientBeanPostProcessor")).isFalse();
-                  "Application Context DOES NOT contain otelWebClientBeanPostProcessor bean",
-                  context.containsBean("otelWebClientBeanPostProcessor"));
             });
   }
 
   @Test
-  public void
+  @DisplayName(
-      should_initialize_WebClientBeanPostProccesor_bean_when_httpclients_enabled_property_is_MISSING() {
+      "when httpclients enabled property is MISSING should initialize WebClientBeanPostProccesor bean")
+  void noProperty() {
     this.contextRunner.run(
         (context) -> {
-          assertNotNull(
+          assertThat(
-              "Application Context contains WebClientBeanPostProcessor bean",
+                  context.getBean(
-              context.getBean("otelWebClientBeanPostProcessor", WebClientBeanPostProcessor.class));
+                      "otelWebClientBeanPostProcessor", WebClientBeanPostProcessor.class))
+              .isNotNull();
         });
   }
 }

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/httpclients/webclient/WebClientBeanPostProcessorTest.java

@@ -16,12 +16,12 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.httpclients.webclient;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertTrue;
 
 import io.opentelemetry.instrumentation.springwebflux.client.WebClientTracingFilter;
 import io.opentelemetry.trace.Tracer;
 import org.junit.Test;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -29,60 +29,64 @@ import org.springframework.web.reactive.function.client.WebClient;
 
 /** Spring bean post processor test {@link WebClientBeanPostProcessor} */
 @RunWith(MockitoJUnitRunner.class)
-public class WebClientBeanPostProcessorTest {
+class WebClientBeanPostProcessorTest {
 
   @Mock Tracer tracer;
 
   WebClientBeanPostProcessor webClientBeanPostProcessor = new WebClientBeanPostProcessor(tracer);
 
   @Test
-  public void
+  @DisplayName(
-      should_return_object_if_processed_bean_is_NOT_of_type_WebClient_or_WebClientBuilder() {
+      "when processed bean is NOT of type WebClient or WebClientBuilder should return Object")
-    assertEquals(
+  void returnsObject() {
-        webClientBeanPostProcessor
+
-            .postProcessAfterInitialization(new Object(), "testObject")
+    assertThat(
-            .getClass(),
+            webClientBeanPostProcessor.postProcessAfterInitialization(new Object(), "testObject"))
-        Object.class);
+        .isExactlyInstanceOf(Object.class);
   }
 
   @Test
-  public void should_return_web_client_if_processed_bean_is_of_type_WebClient() {
+  @DisplayName("when processed bean is of type WebClient should return WebClient")
-    WebClient webClient = WebClient.create();
+  void returnsWebClient() {
-
+    assertThat(
-    assertTrue(
+            webClientBeanPostProcessor.postProcessAfterInitialization(
-        webClientBeanPostProcessor.postProcessAfterInitialization(webClient, "testWebClient")
+                WebClient.create(), "testWebClient"))
-            instanceof WebClient);
+        .isInstanceOf(WebClient.class);
   }
 
   @Test
-  public void should_return_WebClientBuilder_if_processed_bean_is_of_type_WebClientBuilder() {
+  @DisplayName("when processed bean is of type WebClientBuilder should return WebClientBuilder")
-    WebClient.Builder webClientBuilder = WebClient.builder();
+  void returnsWebClientBuilder() {
-
+    assertThat(
-    assertTrue(
+            webClientBeanPostProcessor.postProcessAfterInitialization(
-        webClientBeanPostProcessor.postProcessAfterInitialization(
+                WebClient.builder(), "testWebClientBuilder"))
-                webClientBuilder, "testWebClientBuilder")
+        .isInstanceOf(WebClient.Builder.class);
-            instanceof WebClient.Builder);
   }
 
   @Test
-  public void should_add_exchange_filter_to_WebClient() {
+  @DisplayName("when processed bean is of type WebClient should add exchange filter to WebClient")
+  void addsExchangeFilterWebClient() {
     WebClient webClient = WebClient.create();
     Object processedWebClient =
         webClientBeanPostProcessor.postProcessAfterInitialization(webClient, "testWebClient");
 
-    assertTrue(processedWebClient instanceof WebClient);
+    assertThat(processedWebClient).isInstanceOf(WebClient.class);
     ((WebClient) processedWebClient)
         .mutate()
         .filters(
             functions -> {
-              assertEquals(
+              assertThat(
-                  functions.stream().filter(wctf -> wctf instanceof WebClientTracingFilter).count(),
+                      functions.stream()
-                  1);
+                          .filter(wctf -> wctf instanceof WebClientTracingFilter)
+                          .count())
+                  .isEqualTo(1);
             });
   }
 
   @Test
-  public void should_add_ONE_exchange_filter_to_WebClientBuilder() {
+  @DisplayName(
+      "when processed bean is of type WebClientBuilder should add ONE exchange filter to WebClientBuilder")
+  void addsExchangeFilterWebClientBuilder() {
 
     WebClient.Builder webClientBuilder = WebClient.builder();
     webClientBeanPostProcessor.postProcessAfterInitialization(
@@ -94,8 +98,9 @@ public class WebClientBeanPostProcessorTest {
 
     webClientBuilder.filters(
         functions -> {
-          assertEquals(
+          assertThat(
-              functions.stream().filter(wctf -> wctf instanceof WebClientTracingFilter).count(), 1);
+                  functions.stream().filter(wctf -> wctf instanceof WebClientTracingFilter).count())
+              .isEqualTo(1);
         });
   }
 }

instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/webmvc/WebMVCFilterAutoConfigurationTest.java

@@ -16,17 +16,17 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.webmvc;
 
-import static org.junit.Assert.assertFalse;
+import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertNotNull;
 
 import io.opentelemetry.instrumentation.spring.autoconfigure.TracerAutoConfiguration;
 import io.opentelemetry.instrumentation.springwebmvc.WebMVCTracingFilter;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 
 /** Spring Boot auto configuration test for {@link WebMVCFilterAutoConfiguration} */
-public class WebMVCFilterAutoConfigurationTest {
+class WebMVCFilterAutoConfigurationTest {
   private final ApplicationContextRunner contextRunner =
       new ApplicationContextRunner()
           .withConfiguration(
@@ -34,36 +34,35 @@ public class WebMVCFilterAutoConfigurationTest {
                   TracerAutoConfiguration.class, WebMVCFilterAutoConfiguration.class));
 
   @Test
-  public void should_initialize_WebMvcTracingFilter_bean_when_web_is_enabled() {
+  @DisplayName("when web is ENABLED should initialize WebMvcTracingFilter bean")
+  void webEnabled() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.web.enabled=true")
         .run(
             (context) -> {
-              assertNotNull(
+              assertThat(context.getBean("otelWebMVCTracingFilter", WebMVCTracingFilter.class))
-                  "Application Context contains WebMVCTracingFilter bean",
+                  .isNotNull();
-                  context.getBean("otelWebMVCTracingFilter", WebMVCTracingFilter.class));
             });
   }
 
   @Test
-  public void should_NOT_initialize_WebMvcTracingFilter_bean_when_web_is_NOT_enabled() {
+  @DisplayName("when web is DISABLED should NOT initialize WebMvcTracingFilter bean")
+  void disabledProperty() {
     this.contextRunner
         .withPropertyValues("opentelemetry.trace.web.enabled=false")
         .run(
             (context) -> {
-              assertFalse(
+              assertThat(context.containsBean("otelWebMVCTracingFilter")).isFalse();
-                  "Application Context DOES NOT contain WebMVCTracingFilter bean",
-                  context.containsBean("otelWebMVCTracingFilter"));
             });
   }
 
   @Test
-  public void should_initialize_WebMvcTracingFilter_bean_when_web_enabled_property_is_MISSING() {
+  @DisplayName("when web property is MISSING should initialize WebMvcTracingFilter bean")
+  void noProperty() {
     this.contextRunner.run(
         (context) -> {
-          assertNotNull(
+          assertThat(context.getBean("otelWebMVCTracingFilter", WebMVCTracingFilter.class))
-              "Application Context contains WebMVCTracingFilter bean",
+              .isNotNull();
-              context.getBean("otelWebMVCTracingFilter", WebMVCTracingFilter.class));
         });
   }
 }