test:migrate JUnit 4 + PowerMock to JUnit 5 + Mockito in logger-admin,opentelemetry modules

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/Log4j2LoggerProcessUnitTest.java

@@ -13,21 +13,17 @@
 
 import com.tencent.trpc.core.logger.LoggerLevel;
 import org.apache.logging.log4j.core.config.LoggerConfig;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 public class Log4j2LoggerProcessUnitTest {
 
     public static final String UNIT_TEST = "unit-test";
-    
+
     private Log4j2LoggerProcessUnit log4j2LoggerProcessUnit;
-    @Rule
-    public ExpectedException expectedEx = ExpectedException.none();
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         log4j2LoggerProcessUnit = new Log4j2LoggerProcessUnit();
     }
@@ -41,7 +37,7 @@ public void testInit() {
     public void testSetLogger() {
         log4j2LoggerProcessUnit.addLogger(UNIT_TEST, new LoggerConfig());
         String logger = log4j2LoggerProcessUnit.setLoggerLevel(UNIT_TEST, LoggerLevel.ALL);
-        Assert.assertEquals(logger, "ERROR");
+        Assertions.assertEquals(logger, "ERROR");
     }
 
-}
+}

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/LogbackLoggerProcessUnitTest.java

@@ -11,38 +11,31 @@
 
 package com.tencent.trpc.logger.admin;
 
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.Mockito.when;
 
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.LoggerContext;
 import com.tencent.trpc.core.logger.LoggerLevel;
 import com.tencent.trpc.core.logger.slf4j.Slf4jLogger;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.slf4j.LoggerFactory;
 import java.util.List;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({LoggerFactory.class})
 public class LogbackLoggerProcessUnitTest {
 
     public static final String LOGGER = "logger";
     public static final String LOGGER_ROOT = "ROOT";
     public static final String LOGGER_DEBUG = "DEBUG";
 
-    @Rule
-    public ExpectedException expectedEx = ExpectedException.none();
-
     private LogbackLoggerProcessUnit logger;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         logger = new LogbackLoggerProcessUnit();
         logger.setLoggerLevel(LOGGER, LoggerLevel.ALL);
@@ -51,38 +44,38 @@ public void setUp() throws Exception {
 
     @Test
     public void testInit() {
-        expectedEx.expect(ClassCastException.class);
-        expectedEx.expectMessage("cannot be cast");
-        logger.init();
+        ClassCastException exception = assertThrows(ClassCastException.class,
+                () -> logger.init());
+        assertTrue(exception.getMessage().contains("cannot be cast"));
     }
 
     @Test
-    @PrepareForTest({LoggerFactory.class})
     public void testInitSuccess() {
-        mockStatic(LoggerFactory.class);
-        when(LoggerFactory.getILoggerFactory()).thenReturn(new LoggerContext());
-        logger.init();
+        try (MockedStatic<LoggerFactory> mockedLoggerFactory = Mockito.mockStatic(LoggerFactory.class)) {
+            when(LoggerFactory.getILoggerFactory()).thenReturn(new LoggerContext());
+            logger.init();
+        }
     }
 
     @Test
     public void testGetLoggerLevelInfoByError() {
-        expectedEx.expect(ClassCastException.class);
-        expectedEx.expectMessage("cannot be cast");
-        Assert.assertNotNull(logger.getLoggerLevelInfo());
+        ClassCastException exception = assertThrows(ClassCastException.class,
+                () -> logger.getLoggerLevelInfo());
+        assertTrue(exception.getMessage().contains("cannot be cast"));
     }
 
     @Test
     public void testGetLoggerLevelInfo() {
         addLoggerToUnit();
         List<LoggerLevelInfo> info = logger.getLoggerLevelInfo();
-        Assert.assertNotNull(info);
+        Assertions.assertNotNull(info);
     }
 
     @Test
     public void testSetLogger() {
         addLoggerToUnit();
         String loggerLevel = logger.setLoggerLevel(LOGGER, LoggerLevel.ALL);
-        Assert.assertEquals(LOGGER_DEBUG, loggerLevel);
+        Assertions.assertEquals(LOGGER_DEBUG, loggerLevel);
     }
 
     private void addLoggerToUnit() {
@@ -91,4 +84,4 @@ private void addLoggerToUnit() {
         this.logger.addLogger(LOGGER, logger);
     }
 
-}
+}

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/LoggerLevelInfoTest.java

@@ -12,15 +12,15 @@
 package com.tencent.trpc.logger.admin;
 
 import com.tencent.trpc.core.logger.LoggerLevel;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 public class LoggerLevelInfoTest {
 
     private LoggerLevelInfo loggerLevelInfo;
 
-    @Before
+    @BeforeEach
     public void setUp() {
         loggerLevelInfo = new LoggerLevelInfo();
         loggerLevelInfo.setLoggerName("logger");
@@ -29,17 +29,17 @@ public void setUp() {
 
     @Test
     public void testGetLoggerName() {
-        Assert.assertEquals("logger", loggerLevelInfo.getLoggerName());
+        Assertions.assertEquals("logger", loggerLevelInfo.getLoggerName());
     }
 
     @Test
     public void testGetLevel() {
-        Assert.assertEquals(LoggerLevel.ALL.name(), loggerLevelInfo.getLevel());
+        Assertions.assertEquals(LoggerLevel.ALL.name(), loggerLevelInfo.getLevel());
     }
 
     @Test
     public void testTestToString() {
-        Assert.assertTrue(loggerLevelInfo.toString().contains("LoggerLevelInfo"));
+        Assertions.assertTrue(loggerLevelInfo.toString().contains("LoggerLevelInfo"));
     }
 
-}
+}

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/LoggerManagerTest.java

@@ -13,7 +13,7 @@
 
 import com.tencent.trpc.core.logger.LoggerLevel;
 import java.util.List;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class LoggerManagerTest {
 

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/LoggerProcessUnitFactoryTest.java

@@ -1,52 +1,73 @@
 package com.tencent.trpc.logger.admin;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import ch.qos.logback.classic.LoggerContext;
-import org.apache.logging.slf4j.Log4jLoggerFactory;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import java.lang.reflect.Field;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 import org.slf4j.helpers.NOPLoggerFactory;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
-@RunWith(PowerMockRunner.class)
 public class LoggerProcessUnitFactoryTest {
 
+    @BeforeEach
+    public void setUp() throws Exception {
+        resetLoggerProcessUnit();
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        resetLoggerProcessUnit();
+    }
+
+    /**
+     * Reset static variable of LoggerProcessUnitFactory via reflection
+     */
+    private void resetLoggerProcessUnit() throws Exception {
+        Field field = LoggerProcessUnitFactory.class.getDeclaredField("loggerProcessUnit");
+        field.setAccessible(true);
+        field.set(null, null);
+    }
+
     @Test
-    @PrepareForTest({LoggerFactory.class})
     public void testGetGetLoggerProcessUnit() {
-        PowerMockito.mockStatic(LoggerFactory.class);
-        PowerMockito.when(LoggerFactory.getILoggerFactory()).thenReturn(new Log4jLoggerFactory());
-        LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
-        assertNotNull(log);
-        assertTrue(log instanceof Log4j2LoggerProcessUnit);
+        try (MockedStatic<LoggerFactory> mockedLoggerFactory = Mockito.mockStatic(LoggerFactory.class);
+             MockedStatic<LoggerFactoryEnum> mockedEnum = Mockito.mockStatic(LoggerFactoryEnum.class)) {
+            // Mock LoggerFactoryEnum.getLoggerFactoryEnum to return LOG4J2_FACTORY
+            mockedLoggerFactory.when(LoggerFactory::getILoggerFactory).thenReturn(new NOPLoggerFactory());
+            mockedEnum.when(() -> LoggerFactoryEnum.getLoggerFactoryEnum(Mockito.anyString()))
+                    .thenReturn(LoggerFactoryEnum.LOG4J2_FACTORY);
+            LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
+            assertNotNull(log);
+            assertTrue(log instanceof Log4j2LoggerProcessUnit);
+        }
     }
 
-
     @Test
-    @PrepareForTest({LoggerFactory.class})
     public void testLogback() {
-        PowerMockito.mockStatic(LoggerFactory.class);
-        PowerMockito.when(LoggerFactory.getILoggerFactory()).thenReturn(new LoggerContext());
-        LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
-        assertNotNull(log);
-        assertTrue(log instanceof LogbackLoggerProcessUnit);
-        log = LoggerProcessUnitFactory.getLoggerProcessUnit();
-        assertNotNull(log);
+        try (MockedStatic<LoggerFactory> mockedLoggerFactory = Mockito.mockStatic(LoggerFactory.class)) {
+            mockedLoggerFactory.when(LoggerFactory::getILoggerFactory).thenReturn(new LoggerContext());
+            LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
+            assertNotNull(log);
+            assertTrue(log instanceof LogbackLoggerProcessUnit);
+            log = LoggerProcessUnitFactory.getLoggerProcessUnit();
+            assertNotNull(log);
+        }
     }
 
     @Test
-    @PrepareForTest({LoggerFactory.class})
     public void testUnSupport() {
-        PowerMockito.mockStatic(LoggerFactory.class);
-        PowerMockito.when(LoggerFactory.getILoggerFactory()).thenReturn(new NOPLoggerFactory());
-        LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
-        assertNotNull(log);
-        assertTrue(log instanceof UnSupportLoggerProcessUnit);
+        try (MockedStatic<LoggerFactory> mockedLoggerFactory = Mockito.mockStatic(LoggerFactory.class)) {
+            mockedLoggerFactory.when(LoggerFactory::getILoggerFactory).thenReturn(new NOPLoggerFactory());
+            LoggerProcessUnit log = LoggerProcessUnitFactory.getLoggerProcessUnit();
+            assertNotNull(log);
+            assertTrue(log instanceof UnSupportLoggerProcessUnit);
+        }
     }
 
-}
+}

trpc-logger/trpc-logger-admin/src/test/java/com/tencent/trpc/logger/admin/UnSupportLoggerProcessUnitTest.java

@@ -12,19 +12,17 @@
 package com.tencent.trpc.logger.admin;
 
 import com.tencent.trpc.core.logger.LoggerLevel;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class UnSupportLoggerProcessUnitTest {
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-    @Rule
-    public ExpectedException expectedEx = ExpectedException.none();
+public class UnSupportLoggerProcessUnitTest {
 
     private UnSupportLoggerProcessUnit unSupportLoggerProcessUnit;
 
-    @Before
+    @BeforeEach
     public void setUp() {
         unSupportLoggerProcessUnit = new UnSupportLoggerProcessUnit();
     }
@@ -36,23 +34,23 @@ public void testInit() {
 
     @Test
     public void testGetLoggers() {
-        expectedEx.expect(UnsupportedOperationException.class);
-        expectedEx.expectMessage("Current log frame doesn't support this operation!");
-        unSupportLoggerProcessUnit.getLoggers();
+        UnsupportedOperationException exception = assertThrows(UnsupportedOperationException.class,
+                () -> unSupportLoggerProcessUnit.getLoggers());
+        assertEquals("Current log frame doesn't support this operation!", exception.getMessage());
     }
 
     @Test
     public void testGetLoggerLevelInfo() {
-        expectedEx.expect(UnsupportedOperationException.class);
-        expectedEx.expectMessage("Current log frame doesn't support this operation!");
-        unSupportLoggerProcessUnit.getLoggerLevelInfo();
+        UnsupportedOperationException exception = assertThrows(UnsupportedOperationException.class,
+                () -> unSupportLoggerProcessUnit.getLoggerLevelInfo());
+        assertEquals("Current log frame doesn't support this operation!", exception.getMessage());
     }
 
     @Test
     public void testSetLoggerLevel() {
-        expectedEx.expect(UnsupportedOperationException.class);
-        expectedEx.expectMessage("Current log frame doesn't support this operation!");
-        unSupportLoggerProcessUnit.setLoggerLevel("a", LoggerLevel.ALL);
+        UnsupportedOperationException exception = assertThrows(UnsupportedOperationException.class,
+                () -> unSupportLoggerProcessUnit.setLoggerLevel("a", LoggerLevel.ALL));
+        assertEquals("Current log frame doesn't support this operation!", exception.getMessage());
     }
 
-}
+}

trpc-opentelemetry/src/test/java/com/tencent/trpc/opentelemetry/OpenTelemetryFactoryTest.java

@@ -17,8 +17,8 @@
 import io.opentelemetry.api.GlobalOpenTelemetry;
 import java.util.HashMap;
 import java.util.Map;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class OpenTelemetryFactoryTest {
 
@@ -32,7 +32,7 @@ public void factoryInitTest() {
         ExtensionLoader.registerPlugin(pluginConfig);
         OpenTelemetryFactory factory = (OpenTelemetryFactory) ExtensionLoader.getExtensionLoader(
                 TelemetryFactory.class).getExtension(OpenTelemetryFactory.NAME);
-        Assert.assertNotNull(factory);
+        Assertions.assertNotNull(factory);
     }
 
 }