[Migrate][Test] Migrate junit4 -> junit5 test cases in common, service, and spi modules (#12363)

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/ConstantsTest.java

@@ -18,9 +18,8 @@
 package org.apache.dolphinscheduler.common;
 
 import org.apache.commons.lang3.SystemUtils;
-
+import org.junit.jupiter.api.Assertions;
-import org.junit.Assert;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 /**
  * Constants Test
@@ -33,9 +32,9 @@ public class ConstantsTest {
     @Test
     public void testPID() {
         if (SystemUtils.IS_OS_WINDOWS) {
-            Assert.assertEquals(Constants.PID, "handle");
+            Assertions.assertEquals(Constants.PID, "handle");
         } else {
-            Assert.assertEquals(Constants.PID, "pid");
+            Assertions.assertEquals(Constants.PID, "pid");
         }
     }
 

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/exception/ExceptionTest.java

@@ -18,8 +18,8 @@
 package org.apache.dolphinscheduler.common.exception;
 
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class ExceptionTest {
 
@@ -28,16 +28,16 @@ public class ExceptionTest {
         final String message = "Test";
         RuntimeException time = new RuntimeException(message);
 
-        Assert.assertNull(new BaseException().getMessage());
+        Assertions.assertNull(new BaseException().getMessage());
-        Assert.assertNotNull(new BaseException(message).getMessage());
+        Assertions.assertNotNull(new BaseException(message).getMessage());
-        Assert.assertNotNull(new BaseException(message, time).getMessage());
+        Assertions.assertNotNull(new BaseException(message, time).getMessage());
-        Assert.assertNotNull(new BaseException(time).getCause());
+        Assertions.assertNotNull(new BaseException(time).getCause());
-        Assert.assertNotNull(new BaseException(message, time, false, false).getMessage());
+        Assertions.assertNotNull(new BaseException(message, time, false, false).getMessage());
 
-        Assert.assertNull(new StorageOperateNoConfiguredException().getMessage());
+        Assertions.assertNull(new StorageOperateNoConfiguredException().getMessage());
-        Assert.assertNotNull(new StorageOperateNoConfiguredException(message).getMessage());
+        Assertions.assertNotNull(new StorageOperateNoConfiguredException(message).getMessage());
-        Assert.assertNotNull(new StorageOperateNoConfiguredException(message, time).getMessage());
+        Assertions.assertNotNull(new StorageOperateNoConfiguredException(message, time).getMessage());
-        Assert.assertNotNull(new StorageOperateNoConfiguredException(time).getCause());
+        Assertions.assertNotNull(new StorageOperateNoConfiguredException(time).getCause());
-        Assert.assertNotNull(new StorageOperateNoConfiguredException(message, time, false, false).getMessage());
+        Assertions.assertNotNull(new StorageOperateNoConfiguredException(message, time, false, false).getMessage());
     }
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/graph/DAGTest.java

@@ -16,9 +16,10 @@
  */
 package org.apache.dolphinscheduler.common.graph;
 
-import org.junit.After;
+import org.junit.jupiter.api.AfterEach;
-import org.junit.Before;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -26,18 +27,16 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import static org.junit.Assert.*;
-
 public class DAGTest {
   private DAG<Integer, String, String> graph;
   private static final Logger logger = LoggerFactory.getLogger(DAGTest.class);
 
-  @Before
+  @BeforeEach
   public void setup() {
     graph = new DAG<>();
   }
 
-  @After
+  @AfterEach
   public void tearDown() {
     clear();
   }
@@ -46,7 +45,7 @@ public class DAGTest {
     graph = null;
     graph = new DAG<>();
 
-    assertEquals(graph.getNodesCount(), 0);
+    Assertions.assertEquals(graph.getNodesCount(), 0);
   }
 
 
@@ -65,20 +64,20 @@ public class DAGTest {
     }
 
     // construction side
-    assertTrue(graph.addEdge(1, 2));
+    Assertions.assertTrue(graph.addEdge(1, 2));
 
-    assertTrue(graph.addEdge(2, 5));
+    Assertions.assertTrue(graph.addEdge(2, 5));
 
-    assertTrue(graph.addEdge(3, 5));
+    Assertions.assertTrue(graph.addEdge(3, 5));
 
-    assertTrue(graph.addEdge(4, 6));
+    Assertions.assertTrue(graph.addEdge(4, 6));
 
-    assertTrue(graph.addEdge(5, 6));
+    Assertions.assertTrue(graph.addEdge(5, 6));
 
-    assertTrue(graph.addEdge(6, 7));
+    Assertions.assertTrue(graph.addEdge(6, 7));
 
-    assertEquals(graph.getNodesCount(), 7);
+    Assertions.assertEquals(graph.getNodesCount(), 7);
-    assertEquals(graph.getEdgesCount(), 6);
+    Assertions.assertEquals(graph.getEdgesCount(), 6);
 
   }
 
@@ -94,12 +93,12 @@ public class DAGTest {
     graph.addNode(2, null);
     graph.addNode(5, "v(5)");
 
-    assertEquals(graph.getNodesCount(), 3);
+    Assertions.assertEquals(graph.getNodesCount(), 3);
 
-    assertEquals(graph.getNode(1), "v(1)");
+    Assertions.assertEquals(graph.getNode(1), "v(1)");
-    assertTrue(graph.containsNode(1));
+    Assertions.assertTrue(graph.containsNode(1));
 
-    assertFalse(graph.containsNode(10));
+    Assertions.assertFalse(graph.containsNode(10));
   }
 
 
@@ -110,24 +109,24 @@ public class DAGTest {
   public void testAddEdge() {
     clear();
 
-    assertFalse(graph.addEdge(1, 2, "edge(1 -> 2)", false));
+    Assertions.assertFalse(graph.addEdge(1, 2, "edge(1 -> 2)", false));
 
     graph.addNode(1, "v(1)");
 
-    assertTrue(graph.addEdge(1, 2, "edge(1 -> 2)",true));
+    Assertions.assertTrue(graph.addEdge(1, 2, "edge(1 -> 2)",true));
 
     graph.addNode(2, "v(2)");
 
-    assertTrue(graph.addEdge(1, 2, "edge(1 -> 2)",true));
+    Assertions.assertTrue(graph.addEdge(1, 2, "edge(1 -> 2)",true));
 
-    assertFalse(graph.containsEdge(1, 3));
+    Assertions.assertFalse(graph.containsEdge(1, 3));
 
-    assertTrue(graph.containsEdge(1, 2));
+    Assertions.assertTrue(graph.containsEdge(1, 2));
-    assertEquals(graph.getEdgesCount(), 1);
+    Assertions.assertEquals(graph.getEdgesCount(), 1);
 
     int node = 3;
     graph.addNode(node, "v(3)");
-    assertFalse(graph.addEdge(node, node));
+    Assertions.assertFalse(graph.addEdge(node, node));
 
   }
 
@@ -139,7 +138,7 @@ public class DAGTest {
   public void testSubsequentNodes() {
     makeGraph();
 
-    assertEquals(graph.getSubsequentNodes(1).size(), 1);
+    Assertions.assertEquals(graph.getSubsequentNodes(1).size(), 1);
 
   }
 
@@ -151,10 +150,10 @@ public class DAGTest {
   public void testIndegree() {
     makeGraph();
 
-    assertEquals(graph.getIndegree(1), 0);
+    Assertions.assertEquals(graph.getIndegree(1), 0);
-    assertEquals(graph.getIndegree(2), 1);
+    Assertions.assertEquals(graph.getIndegree(2), 1);
-    assertEquals(graph.getIndegree(3), 0);
+    Assertions.assertEquals(graph.getIndegree(3), 0);
-    assertEquals(graph.getIndegree(4), 0);
+    Assertions.assertEquals(graph.getIndegree(4), 0);
   }
 
 
@@ -165,11 +164,11 @@ public class DAGTest {
   public void testBeginNode() {
     makeGraph();
 
-    assertEquals(graph.getBeginNode().size(), 3);
+    Assertions.assertEquals(graph.getBeginNode().size(), 3);
 
-    assertTrue(graph.getBeginNode().contains(1));
+    Assertions.assertTrue(graph.getBeginNode().contains(1));
-    assertTrue(graph.getBeginNode().contains(3));
+    Assertions.assertTrue(graph.getBeginNode().contains(3));
-    assertTrue(graph.getBeginNode().contains(4));
+    Assertions.assertTrue(graph.getBeginNode().contains(4));
   }
 
 
@@ -180,9 +179,9 @@ public class DAGTest {
   public void testEndNode() {
     makeGraph();
 
-    assertEquals(graph.getEndNode().size(), 1);
+    Assertions.assertEquals(graph.getEndNode().size(), 1);
 
-    assertTrue(graph.getEndNode().contains(7));
+    Assertions.assertTrue(graph.getEndNode().contains(7));
   }
 
 
@@ -204,10 +203,10 @@ public class DAGTest {
       graph.addEdge(2, 3);
       graph.addEdge(3, 4);
 
-      assertFalse(graph.hasCycle());
+      Assertions.assertFalse(graph.hasCycle());
     } catch (Exception e) {
       e.printStackTrace();
-      fail();
+      Assertions.fail();
     }
 
 
@@ -215,15 +214,15 @@ public class DAGTest {
       boolean addResult = graph.addEdge(4, 1);
 
       if(!addResult){
-        assertTrue(true);
+        Assertions.assertTrue(true);
       }
 
       graph.addEdge(5, 1);
 
-      assertFalse(graph.hasCycle());
+      Assertions.assertFalse(graph.hasCycle());
     } catch (Exception e) {
       e.printStackTrace();
-      fail();
+      Assertions.fail();
     }
 
     clear();
@@ -241,10 +240,10 @@ public class DAGTest {
       graph.addEdge(4, 5);
       graph.addEdge(5, 2);//会失败，添加不进去，所以下一步无环
 
-      assertFalse(graph.hasCycle());
+      Assertions.assertFalse(graph.hasCycle());
     } catch (Exception e) {
       e.printStackTrace();
-      fail();
+      Assertions.fail();
     }
   }
 
@@ -264,10 +263,10 @@ public class DAGTest {
       topoList.add(6);
       topoList.add(7);
 
-      assertEquals(graph.topologicalSort(),topoList);
+      Assertions.assertEquals(graph.topologicalSort(),topoList);
     } catch (Exception e) {
       e.printStackTrace();
-      fail();
+      Assertions.fail();
     }
   }
 
@@ -290,11 +289,11 @@ public class DAGTest {
       topoList.add(4);
       topoList.add(5);
 
-      assertEquals(graph.topologicalSort(),topoList);
+      Assertions.assertEquals(graph.topologicalSort(),topoList);
 
     } catch (Exception e) {
       e.printStackTrace();
-      fail();
+      Assertions.fail();
     }
 
   }
@@ -318,24 +317,24 @@ public class DAGTest {
     }
 
     // construction node
-    assertTrue(graph.addEdge(1, 2));
+    Assertions.assertTrue(graph.addEdge(1, 2));
 
-    assertTrue(graph.addEdge(1, 3));
+    Assertions.assertTrue(graph.addEdge(1, 3));
 
-    assertTrue(graph.addEdge(2, 5));
+    Assertions.assertTrue(graph.addEdge(2, 5));
-    assertTrue(graph.addEdge(3, 4));
+    Assertions.assertTrue(graph.addEdge(3, 4));
 
-    assertTrue(graph.addEdge(4, 6));
+    Assertions.assertTrue(graph.addEdge(4, 6));
 
-    assertTrue(graph.addEdge(5, 6));
+    Assertions.assertTrue(graph.addEdge(5, 6));
 
-    assertTrue(graph.addEdge(6, 7));
+    Assertions.assertTrue(graph.addEdge(6, 7));
-    assertTrue(graph.addEdge(6, 8));
+    Assertions.assertTrue(graph.addEdge(6, 8));
 
 
 
 
-    assertEquals(graph.getNodesCount(), 8);
+    Assertions.assertEquals(graph.getNodesCount(), 8);
 
     logger.info(Arrays.toString(graph.topologicalSort().toArray()));
 
@@ -347,7 +346,7 @@ public class DAGTest {
       logger.info(i + " subsequentNodes : " + graph.getSubsequentNodes(i));
     }
     logger.info(6 + "  previousNodesb: " + graph.getPreviousNodes(6));
-    assertEquals(5, graph.getSubsequentNodes(2).toArray()[0]);
+    Assertions.assertEquals(5, graph.getSubsequentNodes(2).toArray()[0]);
 
   }
 
@@ -357,7 +356,7 @@ public class DAGTest {
     try {
       graph.topologicalSort();
     } catch (Exception e) {
-      assertTrue(e.getMessage().contains("serious error: graph has cycle"));
+      Assertions.assertTrue(e.getMessage().contains("serious error: graph has cycle"));
     }
   }
 

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/os/OSUtilsTest.java

@@ -16,17 +16,15 @@
  */
 package org.apache.dolphinscheduler.common.os;
 
-import org.apache.dolphinscheduler.common.utils.OSUtils;
-
 import org.apache.commons.lang3.SystemUtils;
-
+import org.apache.dolphinscheduler.common.utils.OSUtils;
-import java.util.List;
+import org.junit.jupiter.api.Assertions;
-
+import org.junit.jupiter.api.Test;
-import org.junit.Assert;
-import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.List;
+
 /**
  * OSUtilsTest
  */
@@ -38,35 +36,35 @@ public class OSUtilsTest {
     public void memoryUsage() {
         double memoryUsage = OSUtils.memoryUsage();
         logger.info("memoryUsage : {}", memoryUsage);
-        Assert.assertTrue(memoryUsage >= 0.0);
+        Assertions.assertTrue(memoryUsage >= 0.0);
     }
 
     @Test
     public void diskAvailable() {
         double diskAvailable = OSUtils.diskAvailable();
         logger.info("diskAvailable : {}", diskAvailable);
-        Assert.assertTrue(diskAvailable >= 0.0);
+        Assertions.assertTrue(diskAvailable >= 0.0);
     }
 
     @Test
     public void loadAverage() {
         double loadAverage = OSUtils.loadAverage();
         logger.info("loadAverage : {}", loadAverage);
-        Assert.assertTrue(loadAverage >= 0.0);
+        Assertions.assertTrue(loadAverage >= 0.0);
     }
 
     @Test
     public void cpuUsage() {
         double cpuUsage = OSUtils.cpuUsage();
         logger.info("cpuUsage : {}", cpuUsage);
-        Assert.assertTrue(cpuUsage >= 0.0);
+        Assertions.assertTrue(cpuUsage >= 0.0);
     }
 
     @Test
     public void availablePhysicalMemorySize() {
         double physicalMemorySize = OSUtils.availablePhysicalMemorySize();
         logger.info("physicalMemorySize : {}", physicalMemorySize);
-        Assert.assertTrue(physicalMemorySize >= 0.0);
+        Assertions.assertTrue(physicalMemorySize >= 0.0);
 
     }
 
@@ -74,11 +72,11 @@ public class OSUtilsTest {
     public void existTenantCodeInLinux() {
         if (SystemUtils.IS_OS_LINUX) {
             boolean test = OSUtils.existTenantCodeInLinux("root");
-            Assert.assertTrue(test);
+            Assertions.assertTrue(test);
             boolean test1 = OSUtils.existTenantCodeInLinux("xxxtt");
-            Assert.assertFalse(test1);
+            Assertions.assertFalse(test1);
         } else {
-            Assert.assertFalse("system must be linux", false);
+            Assertions.assertFalse(false, "system must be linux");
         }
 
     }
@@ -87,10 +85,10 @@ public class OSUtilsTest {
     public void existOSTenandCode() {
         if (SystemUtils.IS_OS_LINUX) {
             List<String> userList = OSUtils.getUserList();
-            Assert.assertTrue(userList.contains("root"));
+            Assertions.assertTrue(userList.contains("root"));
-            Assert.assertFalse(userList.contains("xxxtt"));
+            Assertions.assertFalse(userList.contains("xxxtt"));
         } else {
-            Assert.assertFalse("system must be linux", false);
+            Assertions.assertFalse(false, "system must be linux");
 
         }
 

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/CodeGenerateUtilsTest.java

@@ -17,10 +17,10 @@
 
 package org.apache.dolphinscheduler.common.utils;
 
-import java.util.HashSet;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Assert;
+import java.util.HashSet;
-import org.junit.Test;
 
 public class CodeGenerateUtilsTest {
     @Test
@@ -28,7 +28,7 @@ public class CodeGenerateUtilsTest {
         HashSet<Long> existsCode = new HashSet<>();
         for (int i = 0; i < 100; i++) {
             Long currentCode = CodeGenerateUtils.getInstance().genCode();
-            Assert.assertFalse(existsCode.contains(currentCode));
+            Assertions.assertFalse(existsCode.contains(currentCode));
             existsCode.add(currentCode);
         }
     }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/DateUtilsTest.java

@@ -18,7 +18,12 @@
 package org.apache.dolphinscheduler.common.utils;
 
 import org.apache.dolphinscheduler.common.thread.ThreadLocalContext;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
+import javax.management.timer.Timer;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.ZoneId;
@@ -26,21 +31,14 @@ import java.time.ZonedDateTime;
 import java.util.Date;
 import java.util.TimeZone;
 
-import javax.management.timer.Timer;
-
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
 public class DateUtilsTest {
 
-    @Before
+    @BeforeEach
     public void before() {
         ThreadLocalContext.getTimezoneThreadLocal().remove();
     }
 
-    @After
+    @AfterEach
     public void after() {
         ThreadLocalContext.getTimezoneThreadLocal().remove();
     }
@@ -57,7 +55,7 @@ public class DateUtilsTest {
 
         String readableDate = DateUtils.format2Readable(endDate.getTime() - startDate.getTime());
 
-        Assert.assertEquals("01 09:23:08", readableDate);
+        Assertions.assertEquals("01 09:23:08", readableDate);
     }
 
     @Test
@@ -68,67 +66,67 @@ public class DateUtilsTest {
         Date monday = DateUtils.getMonday(curr);
         Date sunday = DateUtils.getSunday(monday);
 
-        Assert.assertEquals(monday, monday1);
+        Assertions.assertEquals(monday, monday1);
-        Assert.assertEquals(sunday, sunday1);
+        Assertions.assertEquals(sunday, sunday1);
 
     }
 
     @Test
     public void dateToString() {
         Date d1 = DateUtils.stringToDate("2019-01-28");
-        Assert.assertNull(d1);
+        Assertions.assertNull(d1);
         d1 = DateUtils.stringToDate("2019-01-28 00:00:00");
-        Assert.assertEquals(DateUtils.dateToString(d1), "2019-01-28 00:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(d1), "2019-01-28 00:00:00");
     }
 
     @Test
     public void getSomeDay() {
         Date d1 = DateUtils.stringToDate("2019-01-31 00:00:00");
         Date curr = DateUtils.getSomeDay(d1, 1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-02-01 00:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-02-01 00:00:00");
-        Assert.assertEquals(DateUtils.dateToString(DateUtils.getSomeDay(d1, -31)), "2018-12-31 00:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(DateUtils.getSomeDay(d1, -31)), "2018-12-31 00:00:00");
     }
 
     @Test
     public void getFirstDayOfMonth() {
         Date d1 = DateUtils.stringToDate("2019-01-31 00:00:00");
         Date curr = DateUtils.getFirstDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-01 00:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-01 00:00:00");
 
         d1 = DateUtils.stringToDate("2019-01-31 01:59:00");
         curr = DateUtils.getFirstDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-01 01:59:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-01 01:59:00");
     }
 
     @Test
     public void getSomeHourOfDay() {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:59:59");
         Date curr = DateUtils.getSomeHourOfDay(d1, -1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 10:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 10:00:00");
         curr = DateUtils.getSomeHourOfDay(d1, 0);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:00:00");
         curr = DateUtils.getSomeHourOfDay(d1, 2);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 13:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 13:00:00");
         curr = DateUtils.getSomeHourOfDay(d1, 24);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-02-01 11:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-02-01 11:00:00");
     }
 
     @Test
     public void getLastDayOfMonth() {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:59:59");
         Date curr = DateUtils.getLastDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
         d1 = DateUtils.stringToDate("2019-01-02 11:59:59");
         curr = DateUtils.getLastDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
 
         d1 = DateUtils.stringToDate("2019-02-02 11:59:59");
         curr = DateUtils.getLastDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-02-28 11:59:59");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-02-28 11:59:59");
 
         d1 = DateUtils.stringToDate("2020-02-02 11:59:59");
         curr = DateUtils.getLastDayOfMonth(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2020-02-29 11:59:59");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2020-02-29 11:59:59");
     }
 
     @Test
@@ -136,7 +134,7 @@ public class DateUtilsTest {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:59:59");
         Date curr = DateUtils.getStartOfDay(d1);
         String expected = new SimpleDateFormat("yyyy-MM-dd").format(d1) + " 00:00:00";
-        Assert.assertEquals(DateUtils.dateToString(curr), expected);
+        Assertions.assertEquals(DateUtils.dateToString(curr), expected);
     }
 
     @Test
@@ -144,27 +142,27 @@ public class DateUtilsTest {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:00:59");
         Date curr = DateUtils.getEndOfDay(d1);
         String expected = new SimpleDateFormat("yyyy-MM-dd").format(d1) + " 23:59:59";
-        Assert.assertEquals(DateUtils.dateToString(curr), expected);
+        Assertions.assertEquals(DateUtils.dateToString(curr), expected);
     }
 
     @Test
     public void getStartOfHour() {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:00:59");
         Date curr = DateUtils.getStartOfHour(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:00:00");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:00:00");
     }
 
     @Test
     public void getEndOfHour() {
         Date d1 = DateUtils.stringToDate("2019-01-31 11:00:59");
         Date curr = DateUtils.getEndOfHour(d1);
-        Assert.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
+        Assertions.assertEquals(DateUtils.dateToString(curr), "2019-01-31 11:59:59");
     }
 
     @Test
     public void getCurrentTimeStamp() {
         String timeStamp = DateUtils.getCurrentTimeStamp();
-        Assert.assertNotNull(timeStamp);
+        Assertions.assertNotNull(timeStamp);
     }
 
     @Test
@@ -174,49 +172,49 @@ public class DateUtilsTest {
         Date start = DateUtils.stringToDate("2020-01-20 11:00:00");
         Date end = DateUtils.stringToDate("2020-01-21 12:10:10");
         String duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("1d 1h 10m 10s", duration);
+        Assertions.assertEquals("1d 1h 10m 10s", duration);
 
         duration = DateUtils.format2Duration(end, start);
-        Assert.assertNull(duration);
+        Assertions.assertNull(duration);
 
         // hours minutes seconds
         start = DateUtils.stringToDate("2020-01-20 11:00:00");
         end = DateUtils.stringToDate("2020-01-20 12:10:10");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("1h 10m 10s", duration);
+        Assertions.assertEquals("1h 10m 10s", duration);
 
         // minutes seconds
         start = DateUtils.stringToDate("2020-01-20 11:00:00");
         end = DateUtils.stringToDate("2020-01-20 11:10:10");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("10m 10s", duration);
+        Assertions.assertEquals("10m 10s", duration);
 
         // minutes seconds
         start = DateUtils.stringToDate("2020-01-20 11:10:00");
         end = DateUtils.stringToDate("2020-01-20 11:10:10");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("10s", duration);
+        Assertions.assertEquals("10s", duration);
 
         start = DateUtils.stringToDate("2020-01-20 11:10:00");
         end = DateUtils.stringToDate("2020-01-21 11:10:10");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("1d 10s", duration);
+        Assertions.assertEquals("1d 10s", duration);
 
         start = DateUtils.stringToDate("2020-01-20 11:10:00");
         end = DateUtils.stringToDate("2020-01-20 16:10:10");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("5h 10s", duration);
+        Assertions.assertEquals("5h 10s", duration);
 
         // startTime = endTime, default 1s
         start = DateUtils.stringToDate("2020-01-20 11:10:00");
         end = DateUtils.stringToDate("2020-01-20 11:10:00");
         duration = DateUtils.format2Duration(start, end);
-        Assert.assertEquals("1s", duration);
+        Assertions.assertEquals("1s", duration);
 
         // endTime is null, use current time
         start = DateUtils.stringToDate("2020-01-20 11:10:00");
         duration = DateUtils.format2Duration(start, null);
-        Assert.assertNotNull(duration);
+        Assertions.assertNotNull(duration);
     }
 
     @Test
@@ -225,16 +223,16 @@ public class DateUtilsTest {
 
         Date date = new Date();
         Date defaultTimeZoneDate = DateUtils.transformTimezoneDate(date, TimeZone.getDefault().getID());
-        Assert.assertEquals(DateUtils.dateToString(date), DateUtils.dateToString(defaultTimeZoneDate));
+        Assertions.assertEquals(DateUtils.dateToString(date), DateUtils.dateToString(defaultTimeZoneDate));
 
         Date targetTimeZoneDate = DateUtils.transformTimezoneDate(date, TimeZone.getDefault().getID(), "Asia/Shanghai");
-        Assert.assertEquals(DateUtils.dateToString(date, TimeZone.getDefault().getID()), DateUtils.dateToString(targetTimeZoneDate, "Asia/Shanghai"));
+        Assertions.assertEquals(DateUtils.dateToString(date, TimeZone.getDefault().getID()), DateUtils.dateToString(targetTimeZoneDate, "Asia/Shanghai"));
     }
 
     @Test
     public void testGetTimezone() {
-        Assert.assertNull(DateUtils.getTimezone(null));
+        Assertions.assertNull(DateUtils.getTimezone(null));
-        Assert.assertEquals(TimeZone.getTimeZone("MST"), DateUtils.getTimezone("MST"));
+        Assertions.assertEquals(TimeZone.getTimeZone("MST"), DateUtils.getTimezone("MST"));
     }
 
     @Test
@@ -243,13 +241,13 @@ public class DateUtilsTest {
         String time = "2019-01-28 00:00:00";
         ThreadLocalContext.timezoneThreadLocal.set("UTC");
         Date utcDate = DateUtils.stringToDate(time);
-        Assert.assertEquals(time, DateUtils.dateToString(utcDate));
+        Assertions.assertEquals(time, DateUtils.dateToString(utcDate));
 
         ThreadLocalContext.timezoneThreadLocal.set("Asia/Shanghai");
         Date shanghaiDate = DateUtils.stringToDate(time);
-        Assert.assertEquals(time, DateUtils.dateToString(shanghaiDate));
+        Assertions.assertEquals(time, DateUtils.dateToString(shanghaiDate));
 
-        Assert.assertEquals(Timer.ONE_HOUR * 8, utcDate.getTime() - shanghaiDate.getTime());
+        Assertions.assertEquals(Timer.ONE_HOUR * 8, utcDate.getTime() - shanghaiDate.getTime());
 
     }
 
@@ -261,7 +259,7 @@ public class DateUtilsTest {
         ZonedDateTime utcNow = asiaShNow.minusHours(8);
         String asiaShNowStr = DateUtils.dateToString(utcNow, asiaSh);
         String utcNowStr = DateUtils.dateToString(asiaShNow, utc);
-        Assert.assertEquals(asiaShNowStr, utcNowStr);
+        Assertions.assertEquals(asiaShNowStr, utcNowStr);
     }
 
     @Test
@@ -272,17 +270,17 @@ public class DateUtilsTest {
         sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
         Date date = sdf.parse(timeString);
         long timeStamp = DateUtils.dateToTimeStamp(date);
-        Assert.assertEquals(1664456400000L, timeStamp);
+        Assertions.assertEquals(1664456400000L, timeStamp);
 
         // Tokyo Date
         String tokyoTime = "2022-09-29 22:00:00";
         sdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));
         date = sdf.parse(tokyoTime);
         timeStamp = DateUtils.dateToTimeStamp(date);
-        Assert.assertEquals(1664456400000L, timeStamp);
+        Assertions.assertEquals(1664456400000L, timeStamp);
 
         date = null;
-        Assert.assertEquals(0L, DateUtils.dateToTimeStamp(date));
+        Assertions.assertEquals(0L, DateUtils.dateToTimeStamp(date));
     }
 
     @Test
@@ -291,13 +289,13 @@ public class DateUtilsTest {
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
         String sd = sdf.format(new Date(timeStamp));
-        Assert.assertEquals("2022-09-29 21:00:00", sd);
+        Assertions.assertEquals("2022-09-29 21:00:00", sd);
 
         sdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));
         sd = sdf.format(new Date(timeStamp));
-        Assert.assertEquals("2022-09-29 22:00:00", sd);
+        Assertions.assertEquals("2022-09-29 22:00:00", sd);
 
         Date date = DateUtils.timeStampToDate(0L);
-        Assert.assertNull(date);
+        Assertions.assertNull(date);
     }
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/EncryptionUtilsTest.java

@@ -16,8 +16,8 @@
  */
 package org.apache.dolphinscheduler.common.utils;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * encryption utils
@@ -27,7 +27,7 @@ public class EncryptionUtilsTest {
 
     @Test
     public void testGetMd5() {
-        Assert.assertEquals(EncryptionUtils.getMd5(null), EncryptionUtils.getMd5(""));
+        Assertions.assertEquals(EncryptionUtils.getMd5(null), EncryptionUtils.getMd5(""));
     }
 
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/FileUtilsTest.java

@@ -17,51 +17,50 @@
 
 package org.apache.dolphinscheduler.common.utils;
 
-import static org.apache.dolphinscheduler.common.Constants.YYYYMMDDHHMMSS;
-
 import org.apache.dolphinscheduler.common.Constants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 
-import org.junit.Assert;
+import static org.apache.dolphinscheduler.common.Constants.YYYYMMDDHHMMSS;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.MockedStatic;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class FileUtilsTest {
 
     @Test
     public void testGetDownloadFilename() {
         try (MockedStatic<DateUtils> mockedDateUtils = Mockito.mockStatic(DateUtils.class)) {
             mockedDateUtils.when(() -> DateUtils.getCurrentTime(YYYYMMDDHHMMSS)).thenReturn("20190101101059");
-            Assert.assertEquals("/tmp/dolphinscheduler/download/20190101101059/test",
+            Assertions.assertEquals("/tmp/dolphinscheduler/download/20190101101059/test",
                     FileUtils.getDownloadFilename("test"));
         }
     }
 
     @Test
     public void testGetUploadFilename() {
-        Assert.assertEquals("/tmp/dolphinscheduler/aaa/resources/bbb",
+        Assertions.assertEquals("/tmp/dolphinscheduler/aaa/resources/bbb",
                 FileUtils.getUploadFilename("aaa", "bbb"));
     }
 
     @Test
     public void testGetProcessExecDir() {
         String dir = FileUtils.getProcessExecDir(1L, 2L, 1, 3, 4);
-        Assert.assertEquals("/tmp/dolphinscheduler/exec/process/1/2_1/3/4", dir);
+        Assertions.assertEquals("/tmp/dolphinscheduler/exec/process/1/2_1/3/4", dir);
     }
 
     @Test
     public void testCreateWorkDirIfAbsent() {
         try {
             FileUtils.createWorkDirIfAbsent("/tmp/createWorkDirAndUserIfAbsent");
-            Assert.assertTrue(true);
+            Assertions.assertTrue(true);
         } catch (Exception e) {
-            Assert.assertTrue(false);
+            Assertions.fail();
         }
     }
 
@@ -69,11 +68,11 @@ public class FileUtilsTest {
     public void testSetValue() {
         try {
             PropertyUtils.setValue(Constants.DATASOURCE_ENCRYPTION_ENABLE, "true");
-            Assert.assertTrue(PropertyUtils.getBoolean(Constants.DATASOURCE_ENCRYPTION_ENABLE));
+            Assertions.assertTrue(PropertyUtils.getBoolean(Constants.DATASOURCE_ENCRYPTION_ENABLE));
             PropertyUtils.setValue(Constants.DATASOURCE_ENCRYPTION_ENABLE, "false");
-            Assert.assertFalse(PropertyUtils.getBoolean(Constants.DATASOURCE_ENCRYPTION_ENABLE));
+            Assertions.assertFalse(PropertyUtils.getBoolean(Constants.DATASOURCE_ENCRYPTION_ENABLE));
         } catch (Exception e) {
-            Assert.assertTrue(false);
+            Assertions.fail();
         }
     }
 
@@ -85,7 +84,7 @@ public class FileUtilsTest {
         FileUtils.writeContent2File(content, filePath);
 
         String fileContent = FileUtils.readFile2Str(new FileInputStream(filePath));
-        Assert.assertEquals(content, fileContent);
+        Assertions.assertEquals(content, fileContent);
     }
 
     @Test
@@ -93,29 +92,29 @@ public class FileUtilsTest {
         // test case which do not directory traversal
         String path;
         path = "abc.txt";
-        Assert.assertFalse(FileUtils.directoryTraversal(path));
+        Assertions.assertFalse(FileUtils.directoryTraversal(path));
 
         path = "abc...txt";
-        Assert.assertFalse(FileUtils.directoryTraversal(path));
+        Assertions.assertFalse(FileUtils.directoryTraversal(path));
 
         path = "..abc.txt";
-        Assert.assertFalse(FileUtils.directoryTraversal(path));
+        Assertions.assertFalse(FileUtils.directoryTraversal(path));
 
         // test case which will directory traversal
         path = "../abc.txt";
-        Assert.assertTrue(FileUtils.directoryTraversal(path));
+        Assertions.assertTrue(FileUtils.directoryTraversal(path));
 
         path = "../../abc.txt";
-        Assert.assertTrue(FileUtils.directoryTraversal(path));
+        Assertions.assertTrue(FileUtils.directoryTraversal(path));
 
         path = "abc../def.txt";
-        Assert.assertTrue(FileUtils.directoryTraversal(path));
+        Assertions.assertTrue(FileUtils.directoryTraversal(path));
 
         path = "abc./def.txt";
-        Assert.assertTrue(FileUtils.directoryTraversal(path));
+        Assertions.assertTrue(FileUtils.directoryTraversal(path));
 
         path = "abc/def...txt";
-        Assert.assertTrue(FileUtils.directoryTraversal(path));
+        Assertions.assertTrue(FileUtils.directoryTraversal(path));
     }
 
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/LocalServerHttpUtilsTest.java

@@ -17,23 +17,19 @@
 
 package org.apache.dolphinscheduler.common.utils;
 
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
 import org.apache.dolphinscheduler.common.Constants;
-
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
-
+import org.junit.jupiter.api.Assertions;
-import org.junit.Assert;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-import junit.framework.Test;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
 public class LocalServerHttpUtilsTest extends TestCase {
 
     public static final Logger logger = LoggerFactory.getLogger(LocalServerHttpUtilsTest.class);
@@ -50,11 +46,11 @@ public class LocalServerHttpUtilsTest extends TestCase {
         // success
         String result = null;
         result = HttpUtils.get("http://localhost:" + server.getServerPort() + "/test.json");
-        Assert.assertNotNull(result);
+        Assertions.assertNotNull(result);
         ObjectNode jsonObject = JSONUtils.parseObject(result);
-        Assert.assertEquals("Github", jsonObject.path("name").asText());
+        Assertions.assertEquals("Github", jsonObject.path("name").asText());
         result = HttpUtils.get("http://123.333.111.33/ccc");
-        Assert.assertNull(result);
+        Assertions.assertNull(result);
     }
 
     public void testGetResponseContentString() {
@@ -68,19 +64,19 @@ public class LocalServerHttpUtilsTest extends TestCase {
 
         String responseContent = null;
         responseContent = HttpUtils.getResponseContentString(httpget, httpclient);
-        Assert.assertNotNull(responseContent);
+        Assertions.assertNotNull(responseContent);
 
         responseContent = HttpUtils.getResponseContentString(null, httpclient);
-        Assert.assertNull(responseContent);
+        Assertions.assertNull(responseContent);
 
         responseContent = HttpUtils.getResponseContentString(httpget, null);
-        Assert.assertNull(responseContent);
+        Assertions.assertNull(responseContent);
     }
 
     public void testGetHttpClient() {
         CloseableHttpClient httpClient1 = HttpUtils.getInstance();
         CloseableHttpClient httpClient2 = HttpUtils.getInstance();
-        Assert.assertEquals(httpClient1, httpClient2);
+        Assertions.assertEquals(httpClient1, httpClient2);
     }
 
     public void testKerberosHttpsGet() {
@@ -89,19 +85,19 @@ public class LocalServerHttpUtilsTest extends TestCase {
         logger.info(PropertyUtils.getString(Constants.JAVA_SECURITY_KRB5_CONF_PATH));
         String url = "https://www.apache.org/";
         logger.info(KerberosHttpClient.get(url));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     public void testHttpsGet() {
         String url = "https://www.apache.org/";
         logger.info(HttpUtils.get(url));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     public void testHttpGet() {
         String url = "http://www.apache.org/";
         logger.info(HttpUtils.get(url));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/NetUtilsTest.java

@@ -17,26 +17,23 @@
 
 package org.apache.dolphinscheduler.common.utils;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.when;
 
 import java.net.InetAddress;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 
 public class NetUtilsTest {
 
     @Test
     public void testGetAddr() {
-        assertEquals(NetUtils.getHost() + ":5678", NetUtils.getAddr(5678));
+        Assertions.assertEquals(NetUtils.getHost() + ":5678", NetUtils.getAddr(5678));
-        assertEquals("127.0.0.1:5678", NetUtils.getAddr("127.0.0.1", 5678));
+        Assertions.assertEquals("127.0.0.1:5678", NetUtils.getAddr("127.0.0.1", 5678));
-        assertEquals("localhost:1234", NetUtils.getAddr("localhost", 1234));
+        Assertions.assertEquals("localhost:1234", NetUtils.getAddr("localhost", 1234));
     }
 
     @Test
@@ -48,23 +45,23 @@ public class NetUtilsTest {
             when(address.getCanonicalHostName())
                     .thenReturn("dolphinscheduler-worker-0.dolphinscheduler-worker-headless.default.svc.cluster.local");
             when(address.getHostName()).thenReturn("dolphinscheduler-worker-0");
-            assertEquals("dolphinscheduler-worker-0.dolphinscheduler-worker-headless", NetUtils.getHost(address));
+            Assertions.assertEquals("dolphinscheduler-worker-0.dolphinscheduler-worker-headless", NetUtils.getHost(address));
 
             address = mock(InetAddress.class);
             when(address.getCanonicalHostName())
                     .thenReturn("busybox-1.default-subdomain.my-namespace.svc.cluster-domain.example");
             when(address.getHostName()).thenReturn("busybox-1");
-            assertEquals("busybox-1.default-subdomain", NetUtils.getHost(address));
+            Assertions.assertEquals("busybox-1.default-subdomain", NetUtils.getHost(address));
 
             address = mock(InetAddress.class);
             when(address.getCanonicalHostName()).thenReturn("dolphinscheduler.cluster-domain.example");
             when(address.getHostName()).thenReturn("dolphinscheduler");
-            assertEquals("dolphinscheduler.cluster-domain.example", NetUtils.getHost(address));
+            Assertions.assertEquals("dolphinscheduler.cluster-domain.example", NetUtils.getHost(address));
 
             address = mock(InetAddress.class);
             when(address.getCanonicalHostName()).thenReturn("dolphinscheduler-worker-0");
             when(address.getHostName()).thenReturn("dolphinscheduler-worker-0");
-            assertEquals("dolphinscheduler-worker-0", NetUtils.getHost(address));
+            Assertions.assertEquals("dolphinscheduler-worker-0", NetUtils.getHost(address));
         }
     }
 
@@ -75,46 +72,46 @@ public class NetUtilsTest {
                 .thenReturn("dolphinscheduler-worker-0.dolphinscheduler-worker-headless.default.svc.cluster.local");
         when(address.getHostName()).thenReturn("dolphinscheduler-worker-0");
         when(address.getHostAddress()).thenReturn("172.17.0.15");
-        assertEquals("172.17.0.15", NetUtils.getHost(address));
+        Assertions.assertEquals("172.17.0.15", NetUtils.getHost(address));
     }
 
     @Test
     public void testGetLocalHost() {
-        assertNotNull(NetUtils.getHost());
+        Assertions.assertNotNull(NetUtils.getHost());
     }
 
     @Test
     public void testIsValidAddress() {
-        assertFalse(NetUtils.isValidV4Address(null));
+        Assertions.assertFalse(NetUtils.isValidV4Address(null));
         InetAddress address = mock(InetAddress.class);
         when(address.isLoopbackAddress()).thenReturn(true);
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("localhost");
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("0.0.0.0");
         when(address.isAnyLocalAddress()).thenReturn(true);
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("127.0.0.1");
         when(address.isLoopbackAddress()).thenReturn(true);
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("1.2.3.4");
-        assertTrue(NetUtils.isValidV4Address(address));
+        Assertions.assertTrue(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("1.2.3.4:80");
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("256.0.0.1");
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("127.0.0.0.1");
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
         address = mock(InetAddress.class);
         when(address.getHostAddress()).thenReturn("-1.2.3.4");
-        assertFalse(NetUtils.isValidV4Address(address));
+        Assertions.assertFalse(NetUtils.isValidV4Address(address));
     }
 
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/PropertyUtilsTest.java

@@ -17,22 +17,19 @@
 
 package org.apache.dolphinscheduler.common.utils;
 
-import static org.junit.Assert.assertNotNull;
-
 import org.apache.dolphinscheduler.common.Constants;
-
+import org.junit.jupiter.api.Assertions;
-import org.junit.Assert;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 public class PropertyUtilsTest {
 
     @Test
     public void getString() {
-        assertNotNull(PropertyUtils.getString(Constants.FS_DEFAULT_FS));
+        Assertions.assertNotNull(PropertyUtils.getString(Constants.FS_DEFAULT_FS));
     }
 
     @Test
     public void getResUploadStartupState() {
-        Assert.assertFalse(PropertyUtils.getResUploadStartupState());
+        Assertions.assertFalse(PropertyUtils.getResUploadStartupState());
     }
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/RetryerUtilsTest.java

@@ -18,8 +18,8 @@ package org.apache.dolphinscheduler.common.utils;
 
 import com.github.rholder.retry.RetryException;
 import com.github.rholder.retry.Retryer;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.concurrent.ExecutionException;
 
@@ -28,21 +28,21 @@ public class RetryerUtilsTest {
     @Test
     public void testDefaultRetryer() {
         Retryer<Boolean> retryer = RetryerUtils.getDefaultRetryer();
-        Assert.assertNotNull(retryer);
+        Assertions.assertNotNull(retryer);
         try {
             boolean result = retryer.call(() -> true);
-            Assert.assertTrue(result);
+            Assertions.assertTrue(result);
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
         Retryer<Boolean> retryer1 = RetryerUtils.getDefaultRetryer(true);
-        Assert.assertEquals(retryer, retryer1);
+        Assertions.assertEquals(retryer, retryer1);
     }
 
     @Test
     public void testDefaultRetryerResultCheck() {
         Retryer<Boolean> retryer = RetryerUtils.getDefaultRetryer();
-        Assert.assertNotNull(retryer);
+        Assertions.assertNotNull(retryer);
         try {
             for (int execTarget = 1; execTarget <= 3; execTarget++) {
                 int finalExecTarget = execTarget;
@@ -51,11 +51,11 @@ public class RetryerUtilsTest {
                     execTime[0]++;
                     return execTime[0] == finalExecTarget;
                 });
-                Assert.assertEquals(finalExecTarget, execTime[0]);
+                Assertions.assertEquals(finalExecTarget, execTime[0]);
-                Assert.assertTrue(result);
+                Assertions.assertTrue(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
         int[] execTime = {0};
         try {
@@ -63,19 +63,19 @@ public class RetryerUtilsTest {
                 execTime[0]++;
                 return execTime[0] == 4;
             });
-            Assert.fail("Retry times not reached");
+            Assertions.fail("Retry times not reached");
         } catch (RetryException e) {
-            Assert.assertEquals(3, e.getNumberOfFailedAttempts());
+            Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
-            Assert.assertEquals(3, execTime[0]);
+            Assertions.assertEquals(3, execTime[0]);
         } catch (ExecutionException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 
     @Test
     public void testDefaultRetryerResultNoCheck() {
         Retryer<Boolean> retryer = RetryerUtils.getDefaultRetryer(false);
-        Assert.assertNotNull(retryer);
+        Assertions.assertNotNull(retryer);
         try {
             for (int execTarget = 1; execTarget <= 5; execTarget++) {
                 int[] execTime = {0};
@@ -83,11 +83,11 @@ public class RetryerUtilsTest {
                     execTime[0]++;
                     return execTime[0] > 1;
                 });
-                Assert.assertEquals(1, execTime[0]);
+                Assertions.assertEquals(1, execTime[0]);
-                Assert.assertFalse(result);
+                Assertions.assertFalse(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 
@@ -101,11 +101,11 @@ public class RetryerUtilsTest {
                     execTime[0]++;
                     return execTime[0] == finalExecTarget;
                 });
-                Assert.assertEquals(finalExecTarget, execTime[0]);
+                Assertions.assertEquals(finalExecTarget, execTime[0]);
-                Assert.assertTrue(result);
+                Assertions.assertTrue(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
         int[] execTime = {0};
         try {
@@ -113,12 +113,12 @@ public class RetryerUtilsTest {
                 execTime[0]++;
                 return execTime[0] == 4;
             });
-            Assert.fail("Recall times not reached");
+            Assertions.fail("Recall times not reached");
         } catch (RetryException e) {
-            Assert.assertEquals(3, e.getNumberOfFailedAttempts());
+            Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
-            Assert.assertEquals(3, execTime[0]);
+            Assertions.assertEquals(3, execTime[0]);
         } catch (ExecutionException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 
@@ -132,11 +132,11 @@ public class RetryerUtilsTest {
                     execTime[0]++;
                     return execTime[0] == finalExecTarget;
                 }, true);
-                Assert.assertEquals(finalExecTarget, execTime[0]);
+                Assertions.assertEquals(finalExecTarget, execTime[0]);
-                Assert.assertTrue(result);
+                Assertions.assertTrue(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
         int[] execTime = {0};
         try {
@@ -144,12 +144,12 @@ public class RetryerUtilsTest {
                 execTime[0]++;
                 return execTime[0] == 4;
             }, true);
-            Assert.fail("Recall times not reached");
+            Assertions.fail("Recall times not reached");
         } catch (RetryException e) {
-            Assert.assertEquals(3, e.getNumberOfFailedAttempts());
+            Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
-            Assert.assertEquals(3, execTime[0]);
+            Assertions.assertEquals(3, execTime[0]);
         } catch (ExecutionException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 
@@ -162,11 +162,11 @@ public class RetryerUtilsTest {
                     execTime[0]++;
                     return execTime[0] > 1;
                 }, false);
-                Assert.assertEquals(1, execTime[0]);
+                Assertions.assertEquals(1, execTime[0]);
-                Assert.assertFalse(result);
+                Assertions.assertFalse(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 
@@ -182,11 +182,11 @@ public class RetryerUtilsTest {
                     }
                     return true;
                 }, checkResult);
-                Assert.assertEquals(finalExecTarget, execTime[0]);
+                Assertions.assertEquals(finalExecTarget, execTime[0]);
-                Assert.assertTrue(result);
+                Assertions.assertTrue(result);
             }
         } catch (ExecutionException | RetryException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
         int[] execTime = {0};
         try {
@@ -197,14 +197,14 @@ public class RetryerUtilsTest {
                 }
                 return true;
             }, checkResult);
-            Assert.fail("Recall times not reached");
+            Assertions.fail("Recall times not reached");
         } catch (RetryException e) {
-            Assert.assertEquals(3, e.getNumberOfFailedAttempts());
+            Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
-            Assert.assertEquals(3, execTime[0]);
+            Assertions.assertEquals(3, execTime[0]);
-            Assert.assertNotNull(e.getCause());
+            Assertions.assertNotNull(e.getCause());
-            Assert.assertEquals(3, Integer.parseInt(e.getCause().getMessage()));
+            Assertions.assertEquals(3, Integer.parseInt(e.getCause().getMessage()));
         } catch (ExecutionException e) {
-            Assert.fail("Retry call failed " + e.getMessage());
+            Assertions.fail("Retry call failed " + e.getMessage());
         }
     }
 

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/ScriptRunnerTest.java

@@ -16,10 +16,10 @@
  */
 package org.apache.dolphinscheduler.common.utils;
 
-import java.io.StringReader;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Assert;
+import java.io.StringReader;
-import org.junit.Test;
 
 public class ScriptRunnerTest {
     @Test
@@ -32,6 +32,6 @@ public class ScriptRunnerTest {
         } catch (Exception e) {
             exception = e;
         }
-        Assert.assertNotNull(exception);
+        Assertions.assertNotNull(exception);
     }
 }

dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/utils/StringTest.java

@@ -16,8 +16,8 @@
  */
 package org.apache.dolphinscheduler.common.utils;
 
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -47,7 +47,7 @@ public class StringTest {
                 }
             }
             double during = (System.currentTimeMillis() - start) / 1000.0;
-            Assert.assertEquals("1_0000000000_0000000001", origin);
+            Assertions.assertEquals("1_0000000000_0000000001", origin);
         }
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/alert/AlertClientServiceTest.java

@@ -24,23 +24,22 @@ import org.apache.dolphinscheduler.remote.command.alert.AlertSendRequestCommand;
 import org.apache.dolphinscheduler.remote.command.alert.AlertSendResponseCommand;
 import org.apache.dolphinscheduler.remote.command.alert.AlertSendResponseResult;
 import org.apache.dolphinscheduler.remote.factory.NettyRemotingClientFactory;
-
+import org.junit.jupiter.api.AfterEach;
-import java.util.ArrayList;
+import org.junit.jupiter.api.Assertions;
-import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
-import java.util.Objects;
+import org.junit.jupiter.api.Test;
-
+import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-@RunWith(MockitoJUnitRunner.class)
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@ExtendWith(MockitoExtension.class)
 public class AlertClientServiceTest {
 
     private static final Logger logger = LoggerFactory.getLogger(AlertClientServiceTest.class);
@@ -51,7 +50,7 @@ public class AlertClientServiceTest {
 
     private MockedStatic<NettyRemotingClientFactory> mockedNettyRemotingClientFactory;
 
-    @Before
+    @BeforeEach
     public void before() throws Exception {
         client = Mockito.mock(NettyRemotingClient.class);
         mockedNettyRemotingClientFactory = Mockito.mockStatic(NettyRemotingClientFactory.class);
@@ -60,7 +59,7 @@ public class AlertClientServiceTest {
         alertClient = new AlertClientService();
     }
 
-    @After
+    @AfterEach
     public void after() {
         mockedNettyRemotingClientFactory.close();
     }
@@ -76,7 +75,7 @@ public class AlertClientServiceTest {
         // 1.alter server does not exist
         AlertSendResponseCommand alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertNull(alertSendResponseCommand);
+        Assertions.assertNull(alertSendResponseCommand);
 
         AlertSendRequestCommand alertSendRequestCommand =
                 new AlertSendRequestCommand(groupId, title, content, WarningType.FAILURE.getCode());
@@ -98,7 +97,7 @@ public class AlertClientServiceTest {
         Mockito.when(client.sendSync(Mockito.any(), Mockito.any(), Mockito.anyLong())).thenReturn(resCommand);
         alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertFalse(alertSendResponseCommand.isSuccess());
+        Assertions.assertFalse(alertSendResponseCommand.isSuccess());
         alertSendResponseCommand.getResResults().forEach(result -> logger
                 .info("alert send response result, status:{}, message:{}", result.isSuccess(), result.getMessage()));
 
@@ -113,7 +112,7 @@ public class AlertClientServiceTest {
         Mockito.when(client.sendSync(Mockito.any(), Mockito.any(), Mockito.anyLong())).thenReturn(resCommand);
         alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertFalse(alertSendResponseCommand.isSuccess());
+        Assertions.assertFalse(alertSendResponseCommand.isSuccess());
         alertSendResponseCommand.getResResults().forEach(result -> logger
                 .info("alert send response result, status:{}, message:{}", result.isSuccess(), result.getMessage()));
 
@@ -127,7 +126,7 @@ public class AlertClientServiceTest {
         Mockito.when(client.sendSync(Mockito.any(), Mockito.any(), Mockito.anyLong())).thenReturn(resCommand);
         alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertFalse(alertSendResponseCommand.isSuccess());
+        Assertions.assertFalse(alertSendResponseCommand.isSuccess());
         alertSendResponseCommand.getResResults().forEach(result -> logger
                 .info("alert send response result, status:{}, message:{}", result.isSuccess(), result.getMessage()));
 
@@ -140,7 +139,7 @@ public class AlertClientServiceTest {
         Mockito.when(client.sendSync(Mockito.any(), Mockito.any(), Mockito.anyLong())).thenReturn(resCommand);
         alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertFalse(alertSendResponseCommand.isSuccess());
+        Assertions.assertFalse(alertSendResponseCommand.isSuccess());
         alertSendResponseCommand.getResResults().forEach(result -> logger
                 .info("alert send response result, status:{}, message:{}", result.isSuccess(), result.getMessage()));
 
@@ -154,7 +153,7 @@ public class AlertClientServiceTest {
         Mockito.when(client.sendSync(Mockito.any(), Mockito.any(), Mockito.anyLong())).thenReturn(resCommand);
         alertSendResponseCommand =
                 alertClient.sendAlert(host, port, groupId, title, content, WarningType.FAILURE.getCode());
-        Assert.assertTrue(alertSendResponseCommand.isSuccess());
+        Assertions.assertTrue(alertSendResponseCommand.isSuccess());
         alertSendResponseCommand.getResResults().forEach(result -> logger
                 .info("alert send response result, status:{}, message:{}", result.isSuccess(), result.getMessage()));
 

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/alert/ProcessAlertManagerTest.java

@@ -24,23 +24,22 @@ import org.apache.dolphinscheduler.dao.AlertDao;
 import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
 import org.apache.dolphinscheduler.dao.entity.ProjectUser;
 import org.apache.dolphinscheduler.dao.entity.TaskInstance;
-
+import org.junit.jupiter.api.Test;
-import java.util.ArrayList;
+import org.junit.jupiter.api.extension.ExtendWith;
-import java.util.Date;
-import java.util.List;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
 /**
  * ProcessAlertManager Test
  */
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class ProcessAlertManagerTest {
 
     private static final Logger logger = LoggerFactory.getLogger(ProcessAlertManagerTest.class);

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/cache/CacheNotifyServiceTest.java

@@ -28,29 +28,23 @@ import org.apache.dolphinscheduler.remote.command.CommandType;
 import org.apache.dolphinscheduler.remote.config.NettyServerConfig;
 import org.apache.dolphinscheduler.service.cache.impl.CacheNotifyServiceImpl;
 import org.apache.dolphinscheduler.service.registry.RegistryClient;
-
+import org.junit.jupiter.api.Assertions;
-import java.util.ArrayList;
+import org.junit.jupiter.api.Test;
-import java.util.List;
+import org.junit.jupiter.api.extension.ExtendWith;
-
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * tenant cache proxy test
  */
-@RunWith(MockitoJUnitRunner.Silent.class)
+@ExtendWith(MockitoExtension.class)
 public class CacheNotifyServiceTest {
 
-    @Rule
-    public final ExpectedException exception = ExpectedException.none();
-
     @InjectMocks
     private CacheNotifyServiceImpl cacheNotifyService;
 
@@ -67,7 +61,7 @@ public class CacheNotifyServiceTest {
 
         NettyRemotingServer nettyRemotingServer = new NettyRemotingServer(serverConfig);
         nettyRemotingServer.registerProcessor(CommandType.CACHE_EXPIRE, (channel, command) -> {
-            Assert.assertEquals(cacheExpireCommand, command);
+            Assertions.assertEquals(cacheExpireCommand, command);
         });
         nettyRemotingServer.start();
 

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/cron/CronUtilsTest.java

@@ -17,36 +17,26 @@
 
 package org.apache.dolphinscheduler.service.cron;
 
-import static com.cronutils.model.field.expression.FieldExpressionFactory.always;
+import com.cronutils.builder.CronBuilder;
-import static com.cronutils.model.field.expression.FieldExpressionFactory.every;
+import com.cronutils.model.Cron;
-import static com.cronutils.model.field.expression.FieldExpressionFactory.on;
+import com.cronutils.model.CronType;
-import static com.cronutils.model.field.expression.FieldExpressionFactory.questionMark;
+import com.cronutils.model.definition.CronDefinitionBuilder;
-
+import com.cronutils.model.field.CronField;
+import com.cronutils.model.field.CronFieldName;
+import com.cronutils.model.field.expression.*;
 import org.apache.dolphinscheduler.common.enums.CycleEnum;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.service.exceptions.CronParseException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.Date;
 
-import org.junit.Assert;
+import static com.cronutils.model.field.expression.FieldExpressionFactory.*;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.cronutils.builder.CronBuilder;
-import com.cronutils.model.Cron;
-import com.cronutils.model.CronType;
-import com.cronutils.model.definition.CronDefinitionBuilder;
-import com.cronutils.model.field.CronField;
-import com.cronutils.model.field.CronFieldName;
-import com.cronutils.model.field.expression.Always;
-import com.cronutils.model.field.expression.And;
-import com.cronutils.model.field.expression.Between;
-import com.cronutils.model.field.expression.Every;
-import com.cronutils.model.field.expression.On;
-import com.cronutils.model.field.expression.QuestionMark;
 
 /**
  * CronUtilsTest
@@ -67,7 +57,7 @@ public class CronUtilsTest {
         String cronAsString = cron.asString();
 
         // 0 */5 * * * ? *  Every five minutes(once every 5 minutes)
-        Assert.assertEquals("0 */5 * * * ? *", cronAsString);
+        Assertions.assertEquals("0 */5 * * * ? *", cronAsString);
     }
 
 
@@ -79,12 +69,12 @@ public class CronUtilsTest {
         String strCrontab = "0 1 2 3 * ? *";
 
         Cron depCron = CronUtils.parse2Cron(strCrontab);
-        Assert.assertEquals("0", depCron.retrieve(CronFieldName.SECOND).getExpression().asString());
+        Assertions.assertEquals("0", depCron.retrieve(CronFieldName.SECOND).getExpression().asString());
-        Assert.assertEquals("1", depCron.retrieve(CronFieldName.MINUTE).getExpression().asString());
+        Assertions.assertEquals("1", depCron.retrieve(CronFieldName.MINUTE).getExpression().asString());
-        Assert.assertEquals("2", depCron.retrieve(CronFieldName.HOUR).getExpression().asString());
+        Assertions.assertEquals("2", depCron.retrieve(CronFieldName.HOUR).getExpression().asString());
-        Assert.assertEquals("3", depCron.retrieve(CronFieldName.DAY_OF_MONTH).getExpression().asString());
+        Assertions.assertEquals("3", depCron.retrieve(CronFieldName.DAY_OF_MONTH).getExpression().asString());
-        Assert.assertEquals("*", depCron.retrieve(CronFieldName.MONTH).getExpression().asString());
+        Assertions.assertEquals("*", depCron.retrieve(CronFieldName.MONTH).getExpression().asString());
-        Assert.assertEquals("*", depCron.retrieve(CronFieldName.YEAR).getExpression().asString());
+        Assertions.assertEquals("*", depCron.retrieve(CronFieldName.YEAR).getExpression().asString());
     }
 
     /**
@@ -93,27 +83,27 @@ public class CronUtilsTest {
     @Test
     public void testScheduleType() throws CronParseException {
         CycleEnum cycleEnum = CronUtils.getMaxCycle(CronUtils.parse2Cron("0 */1 * * * ? *"));
-        Assert.assertEquals("MINUTE", cycleEnum.name());
+        Assertions.assertEquals("MINUTE", cycleEnum.name());
 
         CycleEnum cycleEnum2 = CronUtils.getMaxCycle("0 * * * * ? *");
-        Assert.assertEquals("MINUTE", cycleEnum2.name());
+        Assertions.assertEquals("MINUTE", cycleEnum2.name());
 
         CycleEnum cycleEnum3 = CronUtils.getMiniCycle(CronUtils.parse2Cron("0 * * * * ? *"));
-        Assert.assertEquals("MINUTE", cycleEnum3.name());
+        Assertions.assertEquals("MINUTE", cycleEnum3.name());
 
         CycleEnum cycleEnum4 = CronUtils.getMaxCycle(CronUtils.parse2Cron("0 0 7 * 1 ? *"));
-        Assert.assertEquals("YEAR", cycleEnum4.name());
+        Assertions.assertEquals("YEAR", cycleEnum4.name());
         cycleEnum4 = CronUtils.getMiniCycle(CronUtils.parse2Cron("0 0 7 * 1 ? *"));
-        Assert.assertEquals("DAY", cycleEnum4.name());
+        Assertions.assertEquals("DAY", cycleEnum4.name());
 
         CycleEnum cycleEnum5 = CronUtils.getMaxCycle(CronUtils.parse2Cron("0 0 7 * 1/1 ? *"));
-        Assert.assertEquals("MONTH", cycleEnum5.name());
+        Assertions.assertEquals("MONTH", cycleEnum5.name());
 
         CycleEnum cycleEnum6 = CronUtils.getMaxCycle(CronUtils.parse2Cron("0 0 7 * 1-2 ? *"));
-        Assert.assertEquals("YEAR", cycleEnum6.name());
+        Assertions.assertEquals("YEAR", cycleEnum6.name());
 
         CycleEnum cycleEnum7 = CronUtils.getMaxCycle(CronUtils.parse2Cron("0 0 7 * 1,2 ? *"));
-        Assert.assertEquals("YEAR", cycleEnum7.name());
+        Assertions.assertEquals("YEAR", cycleEnum7.name());
     }
 
     /**
@@ -184,7 +174,7 @@ public class CronUtilsTest {
                 logger.info("can't get scheduleType");
             }
         }
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
@@ -194,31 +184,31 @@ public class CronUtilsTest {
         ZonedDateTime to =
             ZonedDateTime.ofInstant(DateUtils.stringToDate("2020-01-31 00:00:00").toInstant(), ZoneId.systemDefault());
         // test date
-        Assert.assertEquals(0, CronUtils.getFireDateList(to, from, "0 0 0 * * ? ").size());
+        Assertions.assertEquals(0, CronUtils.getFireDateList(to, from, "0 0 0 * * ? ").size());
         try {
             // test error cron
             // should throw exception
             CronUtils.getFireDateList(from, to, "0 0 0 * *").size();
-            Assert.assertTrue(false);
+            Assertions.fail();
         } catch (CronParseException cronParseException) {
-            Assert.assertTrue(true);
+            Assertions.assertTrue(true);
         }
         // test cron
-        Assert.assertEquals(30, CronUtils.getFireDateList(from, to, "0 0 0 * * ? ").size());
+        Assertions.assertEquals(30, CronUtils.getFireDateList(from, to, "0 0 0 * * ? ").size());
         // test other
-        Assert.assertEquals(30, CronUtils.getFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? ")).size());
+        Assertions.assertEquals(30, CronUtils.getFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? ")).size());
-        Assert.assertEquals(5, CronUtils.getSelfFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? "), 5).size());
+        Assertions.assertEquals(5, CronUtils.getSelfFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? "), 5).size());
         from =
             ZonedDateTime.ofInstant(DateUtils.stringToDate("2020-01-01 00:02:00").toInstant(), ZoneId.systemDefault());
         to = ZonedDateTime.ofInstant(DateUtils.stringToDate("2020-01-01 00:02:00").toInstant(), ZoneId.systemDefault());
-        Assert.assertEquals(1,
+        Assertions.assertEquals(1,
             CronUtils.getFireDateList(from.minusSeconds(1L), to, CronUtils.parse2Cron("0 * * * * ? ")).size());
 
         from =
             ZonedDateTime.ofInstant(DateUtils.stringToDate("2020-01-01 00:02:00").toInstant(), ZoneId.systemDefault());
         to = ZonedDateTime.ofInstant(DateUtils.stringToDate("2020-01-01 00:04:00").toInstant(),
             ZoneId.systemDefault());
-        Assert.assertEquals(2,
+        Assertions.assertEquals(2,
             CronUtils.getFireDateList(from.minusSeconds(1L), to.minusSeconds(1L), CronUtils.parse2Cron("0 * * * * ? "))
                 .size());
     }
@@ -227,14 +217,14 @@ public class CronUtilsTest {
     public void getExpirationTime() {
         Date startTime = DateUtils.stringToDate("2020-02-07 18:30:00");
         Date expirationTime = CronUtils.getExpirationTime(startTime, CycleEnum.HOUR);
-        Assert.assertEquals("2020-02-07 19:30:00", DateUtils.dateToString(expirationTime));
+        Assertions.assertEquals("2020-02-07 19:30:00", DateUtils.dateToString(expirationTime));
         expirationTime = CronUtils.getExpirationTime(startTime, CycleEnum.DAY);
-        Assert.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
+        Assertions.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
         expirationTime = CronUtils.getExpirationTime(startTime, CycleEnum.WEEK);
-        Assert.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
+        Assertions.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
         expirationTime = CronUtils.getExpirationTime(startTime, CycleEnum.MONTH);
-        Assert.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
+        Assertions.assertEquals("2020-02-07 23:59:59", DateUtils.dateToString(expirationTime));
         expirationTime = CronUtils.getExpirationTime(startTime, CycleEnum.YEAR);
-        Assert.assertEquals("2020-02-07 18:30:00", DateUtils.dateToString(expirationTime));
+        Assertions.assertEquals("2020-02-07 18:30:00", DateUtils.dateToString(expirationTime));
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/expand/CuringGlobalParamsServiceTest.java

@@ -24,22 +24,18 @@ import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.plugin.task.api.enums.DataType;
 import org.apache.dolphinscheduler.plugin.task.api.enums.Direct;
 import org.apache.dolphinscheduler.plugin.task.api.model.Property;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class CuringGlobalParamsServiceTest {
 
     private static final String placeHolderName = "$[yyyy-MM-dd-1]";
@@ -58,7 +54,7 @@ public class CuringGlobalParamsServiceTest {
 
     private final Map<String, String> globalParamMap = new HashMap<>();
 
-    @Before
+    @BeforeEach
     public void init() {
         globalParamMap.put("globalParams1", "Params1");
     }
@@ -67,19 +63,19 @@ public class CuringGlobalParamsServiceTest {
     public void testConvertParameterPlaceholders() {
         Mockito.when(curingGlobalParamsService.convertParameterPlaceholders(placeHolderName, globalParamMap)).thenReturn("2022-06-26");
         String result = curingGlobalParamsService.convertParameterPlaceholders(placeHolderName, globalParamMap);
-        Assert.assertNotNull(result);
+        Assertions.assertNotNull(result);
     }
 
     @Test
     public void testTimeFunctionNeedExpand() {
         boolean result = curingGlobalParamsService.timeFunctionNeedExpand(placeHolderName);
-        Assert.assertFalse(result);
+        Assertions.assertFalse(result);
     }
 
     @Test
     public void testTimeFunctionExtension() {
         String result = curingGlobalParamsService.timeFunctionExtension(1, "", placeHolderName);
-        Assert.assertNull(result);
+        Assertions.assertNull(result);
     }
 
     @Test
@@ -96,22 +92,22 @@ public class CuringGlobalParamsServiceTest {
 
         //test globalParamList is null
         String result = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null);
-        Assert.assertNull(result);
+        Assertions.assertNull(result);
-        Assert.assertNull(dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, null, null, CommandType.START_CURRENT_TASK_PROCESS, null, null));
+        Assertions.assertNull(dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, null, null, CommandType.START_CURRENT_TASK_PROCESS, null, null));
-        Assert.assertNull(dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, null, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null));
+        Assertions.assertNull(dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, null, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null));
 
         //test globalParamList is not null
         Property property = new Property("testGlobalParam", Direct.IN, DataType.VARCHAR, "testGlobalParam");
         globalParamList.add(property);
 
         String result2 = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, null, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null);
-        Assert.assertEquals(result2, JSONUtils.toJsonString(globalParamList));
+        Assertions.assertEquals(result2, JSONUtils.toJsonString(globalParamList));
 
         String result3 = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, null, null);
-        Assert.assertEquals(result3, JSONUtils.toJsonString(globalParamList));
+        Assertions.assertEquals(result3, JSONUtils.toJsonString(globalParamList));
 
         String result4 = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null);
-        Assert.assertEquals(result4, JSONUtils.toJsonString(globalParamList));
+        Assertions.assertEquals(result4, JSONUtils.toJsonString(globalParamList));
 
         //test var $ startsWith
         globalParamMap.put("bizDate", "${system.biz.date}");
@@ -126,7 +122,7 @@ public class CuringGlobalParamsServiceTest {
         globalParamList.add(property4);
 
         String result5 = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null);
-        Assert.assertEquals(result5, JSONUtils.toJsonString(globalParamList));
+        Assertions.assertEquals(result5, JSONUtils.toJsonString(globalParamList));
 
         Property testStartParamProperty = new Property("testStartParam", Direct.IN, DataType.VARCHAR, "");
         globalParamList.add(testStartParamProperty);
@@ -146,6 +142,6 @@ public class CuringGlobalParamsServiceTest {
         }
 
         String result6 = dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, globalParamMap, globalParamList, CommandType.START_CURRENT_TASK_PROCESS, scheduleTime, null);
-        Assert.assertTrue(result6.contains("20191220"));
+        Assertions.assertTrue(result6.contains("20191220"));
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/expand/TimePlaceholderResolverExpandServiceTest.java

@@ -18,14 +18,14 @@
 package org.apache.dolphinscheduler.service.expand;
 
 import org.apache.commons.lang3.StringUtils;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class TimePlaceholderResolverExpandServiceTest {
 
     @Mock
@@ -39,13 +39,13 @@ public class TimePlaceholderResolverExpandServiceTest {
     @Test
     public void testTimePlaceholderResolverExpandService() {
         boolean checkResult = timePlaceholderResolverExpandService.timeFunctionNeedExpand(placeHolderName);
-        Assert.assertFalse(checkResult);
+        Assertions.assertFalse(checkResult);
         String resultString = timePlaceholderResolverExpandService.timeFunctionExtension(1, "", placeHolderName);
-        Assert.assertTrue(StringUtils.isEmpty(resultString));
+        Assertions.assertTrue(StringUtils.isEmpty(resultString));
 
         boolean implCheckResult = timePlaceholderResolverExpandServiceImpl.timeFunctionNeedExpand(placeHolderName);
-        Assert.assertFalse(implCheckResult);
+        Assertions.assertFalse(implCheckResult);
         String implResultString = timePlaceholderResolverExpandServiceImpl.timeFunctionExtension(1, "", placeHolderName);
-        Assert.assertTrue(StringUtils.isEmpty(implResultString));
+        Assertions.assertTrue(StringUtils.isEmpty(implResultString));
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/LogClientTest.java

@@ -28,17 +28,16 @@ import org.apache.dolphinscheduler.remote.command.log.ViewLogResponseCommand;
 import org.apache.dolphinscheduler.remote.factory.NettyRemotingClientFactory;
 import org.apache.dolphinscheduler.remote.utils.Host;
 import org.apache.dolphinscheduler.service.utils.LoggerUtils;
-
+import org.junit.jupiter.api.Assertions;
-import java.nio.charset.StandardCharsets;
+import org.junit.jupiter.api.Test;
-
+import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.nio.charset.StandardCharsets;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class LogClientTest {
 
     @Test
@@ -56,7 +55,7 @@ public class LogClientTest {
                     .thenReturn("application_xx_11");
             LogClient logClient = new LogClient();
             String log = logClient.viewLog(localMachine, port, path);
-            Assert.assertNotNull(log);
+            Assertions.assertNotNull(log);
         }
     }
 
@@ -71,14 +70,14 @@ public class LogClientTest {
                     .thenReturn(localMachine + "1");
             LogClient logClient = new LogClient();
             String log = logClient.viewLog(localMachine, port, path);
-            Assert.assertNotNull(log);
+            Assertions.assertNotNull(log);
         }
 
         Command command = new Command();
         command.setBody(JSONUtils.toJsonString(new ViewLogResponseCommand("")).getBytes(StandardCharsets.UTF_8));
         LogClient logClient = new LogClient();
         String log = logClient.viewLog(localMachine, port, path);
-        Assert.assertNotNull(log);
+        Assertions.assertNotNull(log);
     }
 
     @Test
@@ -110,7 +109,7 @@ public class LogClientTest {
 
             LogClient logClient = new LogClient();
             String msg = logClient.rollViewLog("localhost", 1234, "/tmp/log", 0, 10);
-            Assert.assertNotNull(msg);
+            Assertions.assertNotNull(msg);
         }
     }
 
@@ -131,7 +130,7 @@ public class LogClientTest {
 
             LogClient logClient = new LogClient();
             byte[] logBytes = logClient.getLogBytes("localhost", 1234, "/tmp/log");
-            Assert.assertNotNull(logBytes);
+            Assertions.assertNotNull(logBytes);
         }
     }
 
@@ -152,7 +151,7 @@ public class LogClientTest {
 
             LogClient logClient = new LogClient();
             Boolean status = logClient.removeTaskLog("localhost", 1234, "/log/path");
-            Assert.assertTrue(status);
+            Assertions.assertTrue(status);
         }
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/LoggerRequestProcessorTest.java

@@ -17,33 +17,32 @@
 
 package org.apache.dolphinscheduler.service.log;
 
+import io.netty.channel.Channel;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
 import org.apache.dolphinscheduler.remote.command.Command;
 import org.apache.dolphinscheduler.remote.command.CommandType;
 import org.apache.dolphinscheduler.remote.command.log.ViewLogRequestCommand;
 import org.apache.dolphinscheduler.service.utils.LoggerUtils;
-
+import org.junit.jupiter.api.AfterEach;
-import org.junit.After;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
-
-import io.netty.channel.Channel;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class LoggerRequestProcessorTest {
 
     private MockedStatic<LoggerUtils> mockedStaticLoggerUtils;
 
-    @Before
+    @BeforeEach
     public void setUp() {
         mockedStaticLoggerUtils = Mockito.mockStatic(LoggerUtils.class);
     }
 
-    @After
+    @AfterEach
     public void after() {
         mockedStaticLoggerUtils.close();
     }
@@ -65,7 +64,7 @@ public class LoggerRequestProcessorTest {
         loggerRequestProcessor.process(channel, command);
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testProcessViewWholeLogRequestError() {
         System.setProperty("DOLPHINSCHEDULER_WORKER_HOME", System.getProperty("user.dir"));
         Channel channel = Mockito.mock(Channel.class);
@@ -78,10 +77,12 @@ public class LoggerRequestProcessorTest {
         command.setBody(JSONUtils.toJsonByteArray(logRequestCommand));
 
         LoggerRequestProcessor loggerRequestProcessor = new LoggerRequestProcessor();
+        Assertions.assertThrows(IllegalArgumentException.class, () -> {
             loggerRequestProcessor.process(channel, command);
+        });
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testProcessViewWholeLogRequestErrorRelativePath() {
         System.setProperty("DOLPHINSCHEDULER_WORKER_HOME", System.getProperty("user.dir"));
         Channel channel = Mockito.mock(Channel.class);
@@ -94,10 +95,12 @@ public class LoggerRequestProcessorTest {
         command.setBody(JSONUtils.toJsonByteArray(logRequestCommand));
 
         LoggerRequestProcessor loggerRequestProcessor = new LoggerRequestProcessor();
+        Assertions.assertThrows(IllegalArgumentException.class, () -> {
             loggerRequestProcessor.process(channel, command);
+        });
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testProcessViewWholeLogRequestErrorStartWith() {
         System.setProperty("DOLPHINSCHEDULER_WORKER_HOME", System.getProperty("user.dir"));
         Channel channel = Mockito.mock(Channel.class);
@@ -109,6 +112,8 @@ public class LoggerRequestProcessorTest {
         command.setBody(JSONUtils.toJsonByteArray(logRequestCommand));
 
         LoggerRequestProcessor loggerRequestProcessor = new LoggerRequestProcessor();
+        Assertions.assertThrows(IllegalArgumentException.class, () -> {
             loggerRequestProcessor.process(channel, command);
+        });
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/MasterLogFilterTest.java

@@ -16,14 +16,12 @@
  */
 package org.apache.dolphinscheduler.service.log;
 
-import org.apache.dolphinscheduler.common.Constants;
-
-import org.junit.Assert;
-import org.junit.Test;
-
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.spi.LoggingEvent;
 import ch.qos.logback.core.spi.FilterReply;
+import org.apache.dolphinscheduler.common.Constants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class MasterLogFilterTest {
 
@@ -50,7 +48,7 @@ public class MasterLogFilterTest {
 
         });
 
-        Assert.assertEquals(FilterReply.ACCEPT, filterReply);
+        Assertions.assertEquals(FilterReply.ACCEPT, filterReply);
 
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/SensitiveDataConverterTest.java

@@ -17,16 +17,15 @@
 
 package org.apache.dolphinscheduler.service.log;
 
-import static org.apache.dolphinscheduler.service.log.SensitiveDataConverter.passwordHandler;
-
 import org.apache.dolphinscheduler.common.Constants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.regex.Pattern;
 
-import org.junit.Assert;
+import static org.apache.dolphinscheduler.service.log.SensitiveDataConverter.passwordHandler;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class SensitiveDataConverterTest {
 
@@ -51,7 +50,7 @@ public class SensitiveDataConverterTest {
 
     @Test
     public void convert() {
-        Assert.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
+        Assertions.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
     }
 
     /**
@@ -62,8 +61,8 @@ public class SensitiveDataConverterTest {
         logger.info("parameter : {}", logMsg);
         logger.info("parameter : {}", passwordHandler(pwdPattern, logMsg));
 
-        Assert.assertNotEquals(logMsg, passwordHandler(pwdPattern, logMsg));
+        Assertions.assertNotEquals(logMsg, passwordHandler(pwdPattern, logMsg));
-        Assert.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
+        Assertions.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
 
     }
 

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/TaskLogDiscriminatorTest.java

@@ -16,14 +16,12 @@
  */
 package org.apache.dolphinscheduler.service.log;
 
-import org.apache.dolphinscheduler.plugin.task.api.TaskConstants;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.spi.LoggingEvent;
+import org.apache.dolphinscheduler.plugin.task.api.TaskConstants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 public class TaskLogDiscriminatorTest {
 
@@ -34,7 +32,7 @@ public class TaskLogDiscriminatorTest {
 
     TaskLogDiscriminator taskLogDiscriminator;
 
-    @Before
+    @BeforeEach
     public void before() {
         taskLogDiscriminator = new TaskLogDiscriminator();
         taskLogDiscriminator.setLogBase("logs");
@@ -75,18 +73,18 @@ public class TaskLogDiscriminatorTest {
                 return TaskConstants.TASK_LOG_LOGGER_NAME;
             }
         });
-        Assert.assertEquals("20220105/101-1-1001", result);
+        Assertions.assertEquals("20220105/101-1-1001", result);
     }
 
     @Test
     public void start() {
         taskLogDiscriminator.start();
-        Assert.assertEquals(true, taskLogDiscriminator.isStarted());
+        Assertions.assertEquals(true, taskLogDiscriminator.isStarted());
     }
 
     @Test
     public void getKey() {
-        Assert.assertEquals("123", taskLogDiscriminator.getKey());
+        Assertions.assertEquals("123", taskLogDiscriminator.getKey());
     }
 
     @Test
@@ -97,7 +95,7 @@ public class TaskLogDiscriminatorTest {
 
     @Test
     public void getLogBase() {
-        Assert.assertEquals("logs", taskLogDiscriminator.getLogBase());
+        Assertions.assertEquals("logs", taskLogDiscriminator.getLogBase());
     }
 
     @Test

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/TaskLogFilterTest.java

@@ -16,14 +16,12 @@
  */
 package org.apache.dolphinscheduler.service.log;
 
-import org.apache.dolphinscheduler.plugin.task.api.TaskConstants;
-
-import org.junit.Assert;
-import org.junit.Test;
-
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.spi.LoggingEvent;
 import ch.qos.logback.core.spi.FilterReply;
+import org.apache.dolphinscheduler.plugin.task.api.TaskConstants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class TaskLogFilterTest {
 
@@ -64,7 +62,7 @@ public class TaskLogFilterTest {
             }
         });
 
-        Assert.assertEquals(FilterReply.ACCEPT, filterReply);
+        Assertions.assertEquals(FilterReply.ACCEPT, filterReply);
 
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/log/WorkerLogFilterTest.java

@@ -16,14 +16,12 @@
  */
 package org.apache.dolphinscheduler.service.log;
 
-import org.apache.dolphinscheduler.common.Constants;
-
-import org.junit.Assert;
-import org.junit.Test;
-
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.spi.LoggingEvent;
 import ch.qos.logback.core.spi.FilterReply;
+import org.apache.dolphinscheduler.common.Constants;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class WorkerLogFilterTest {
 
@@ -60,7 +58,7 @@ public class WorkerLogFilterTest {
 
         });
 
-        Assert.assertEquals(FilterReply.ACCEPT, filterReply);
+        Assertions.assertEquals(FilterReply.ACCEPT, filterReply);
 
     }
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/process/ProcessServiceTest.java

@@ -17,65 +17,18 @@
 
 package org.apache.dolphinscheduler.service.process;
 
-import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING;
+import com.fasterxml.jackson.databind.JsonNode;
-import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_START_PARAMS;
-import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_SUB_PROCESS_DEFINE_CODE;
-import static org.mockito.ArgumentMatchers.any;
-
 import org.apache.dolphinscheduler.common.Constants;
-import org.apache.dolphinscheduler.common.enums.CommandType;
+import org.apache.dolphinscheduler.common.enums.*;
-import org.apache.dolphinscheduler.common.enums.Flag;
-import org.apache.dolphinscheduler.common.enums.ProcessExecutionTypeEnum;
-import org.apache.dolphinscheduler.common.enums.TaskGroupQueueStatus;
-import org.apache.dolphinscheduler.common.enums.UserType;
-import org.apache.dolphinscheduler.common.enums.WarningType;
 import org.apache.dolphinscheduler.common.graph.DAG;
 import org.apache.dolphinscheduler.common.model.TaskNodeRelation;
 import org.apache.dolphinscheduler.common.utils.CodeGenerateUtils;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
-import org.apache.dolphinscheduler.dao.entity.Command;
+import org.apache.dolphinscheduler.dao.entity.*;
-import org.apache.dolphinscheduler.dao.entity.DqExecuteResult;
+import org.apache.dolphinscheduler.dao.mapper.*;
-import org.apache.dolphinscheduler.dao.entity.DqRule;
-import org.apache.dolphinscheduler.dao.entity.DqRuleExecuteSql;
-import org.apache.dolphinscheduler.dao.entity.DqRuleInputEntry;
-import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
-import org.apache.dolphinscheduler.dao.entity.ProcessDefinitionLog;
-import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
-import org.apache.dolphinscheduler.dao.entity.ProcessInstanceMap;
-import org.apache.dolphinscheduler.dao.entity.ProcessTaskRelationLog;
-import org.apache.dolphinscheduler.dao.entity.Resource;
-import org.apache.dolphinscheduler.dao.entity.TaskDefinitionLog;
-import org.apache.dolphinscheduler.dao.entity.TaskGroupQueue;
-import org.apache.dolphinscheduler.dao.entity.TaskInstance;
-import org.apache.dolphinscheduler.dao.entity.User;
-import org.apache.dolphinscheduler.dao.mapper.CommandMapper;
-import org.apache.dolphinscheduler.dao.mapper.DataSourceMapper;
-import org.apache.dolphinscheduler.dao.mapper.DqComparisonTypeMapper;
-import org.apache.dolphinscheduler.dao.mapper.DqExecuteResultMapper;
-import org.apache.dolphinscheduler.dao.mapper.DqRuleExecuteSqlMapper;
-import org.apache.dolphinscheduler.dao.mapper.DqRuleInputEntryMapper;
-import org.apache.dolphinscheduler.dao.mapper.DqRuleMapper;
-import org.apache.dolphinscheduler.dao.mapper.ErrorCommandMapper;
-import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionLogMapper;
-import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
-import org.apache.dolphinscheduler.dao.mapper.ProcessInstanceMapper;
-import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationLogMapper;
-import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationMapper;
-import org.apache.dolphinscheduler.dao.mapper.ResourceMapper;
-import org.apache.dolphinscheduler.dao.mapper.ScheduleMapper;
-import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionLogMapper;
-import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionMapper;
-import org.apache.dolphinscheduler.dao.mapper.TaskGroupMapper;
-import org.apache.dolphinscheduler.dao.mapper.TaskGroupQueueMapper;
-import org.apache.dolphinscheduler.dao.mapper.TaskInstanceMapper;
-import org.apache.dolphinscheduler.dao.mapper.UserMapper;
 import org.apache.dolphinscheduler.dao.repository.ProcessInstanceDao;
-import org.apache.dolphinscheduler.plugin.task.api.enums.dp.DqTaskState;
+import org.apache.dolphinscheduler.plugin.task.api.enums.dp.*;
-import org.apache.dolphinscheduler.plugin.task.api.enums.dp.ExecuteSqlType;
-import org.apache.dolphinscheduler.plugin.task.api.enums.dp.InputType;
-import org.apache.dolphinscheduler.plugin.task.api.enums.dp.OptionSourceType;
-import org.apache.dolphinscheduler.plugin.task.api.enums.dp.ValueType;
 import org.apache.dolphinscheduler.plugin.task.api.model.DateInterval;
 import org.apache.dolphinscheduler.plugin.task.api.model.ResourceInfo;
 import org.apache.dolphinscheduler.service.cron.CronUtilsTest;
@@ -85,39 +38,31 @@ import org.apache.dolphinscheduler.service.expand.CuringParamsService;
 import org.apache.dolphinscheduler.service.model.TaskNode;
 import org.apache.dolphinscheduler.service.task.TaskPluginManager;
 import org.apache.dolphinscheduler.spi.params.base.FormType;
-
+import org.junit.jupiter.api.Assertions;
-import java.util.ArrayList;
+import org.junit.jupiter.api.Test;
-import java.util.Collections;
+import org.junit.jupiter.api.extension.ExtendWith;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.fasterxml.jackson.databind.JsonNode;
+import java.util.*;
+
+import static org.apache.dolphinscheduler.common.Constants.*;
+import static org.mockito.ArgumentMatchers.any;
 
 /**
  * process service test
  */
-@RunWith(MockitoJUnitRunner.Silent.class)
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
 public class ProcessServiceTest {
 
     private static final Logger logger = LoggerFactory.getLogger(CronUtilsTest.class);
-
-    @Rule
-    public final ExpectedException exception = ExpectedException.none();
-
     @InjectMocks
     private ProcessServiceImpl processService;
     @Mock
@@ -203,19 +148,19 @@ public class ProcessServiceTest {
         Mockito.when(processDefineMapper.queryByDefineId(100)).thenReturn(processDefinition);
         Mockito.when(processDefineMapper.queryByCode(10L)).thenReturn(processDefinition);
         command = processService.createSubProcessCommand(parentInstance, childInstance, instanceMap, task);
-        Assert.assertEquals(CommandType.START_PROCESS, command.getCommandType());
+        Assertions.assertEquals(CommandType.START_PROCESS, command.getCommandType());
 
         // father history: start,start failure; child null == command type: start
         parentInstance.setCommandType(CommandType.START_FAILURE_TASK_PROCESS);
         parentInstance.setHistoryCmd("START_PROCESS,START_FAILURE_TASK_PROCESS");
         command = processService.createSubProcessCommand(parentInstance, childInstance, instanceMap, task);
-        Assert.assertEquals(CommandType.START_PROCESS, command.getCommandType());
+        Assertions.assertEquals(CommandType.START_PROCESS, command.getCommandType());
 
         // father history: scheduler,start failure; child null == command type: scheduler
         parentInstance.setCommandType(CommandType.START_FAILURE_TASK_PROCESS);
         parentInstance.setHistoryCmd("SCHEDULER,START_FAILURE_TASK_PROCESS");
         command = processService.createSubProcessCommand(parentInstance, childInstance, instanceMap, task);
-        Assert.assertEquals(CommandType.SCHEDULER, command.getCommandType());
+        Assertions.assertEquals(CommandType.SCHEDULER, command.getCommandType());
 
         // father history: complement,start failure; child null == command type: complement
 
@@ -228,20 +173,20 @@ public class ProcessServiceTest {
         complementMap.put(Constants.CMDPARAM_COMPLEMENT_DATA_END_DATE, endString);
         parentInstance.setCommandParam(JSONUtils.toJsonString(complementMap));
         command = processService.createSubProcessCommand(parentInstance, childInstance, instanceMap, task);
-        Assert.assertEquals(CommandType.COMPLEMENT_DATA, command.getCommandType());
+        Assertions.assertEquals(CommandType.COMPLEMENT_DATA, command.getCommandType());
 
         JsonNode complementDate = JSONUtils.parseObject(command.getCommandParam());
         Date start = DateUtils.stringToDate(complementDate.get(Constants.CMDPARAM_COMPLEMENT_DATA_START_DATE).asText());
         Date end = DateUtils.stringToDate(complementDate.get(Constants.CMDPARAM_COMPLEMENT_DATA_END_DATE).asText());
-        Assert.assertEquals(startString, DateUtils.dateToString(start));
+        Assertions.assertEquals(startString, DateUtils.dateToString(start));
-        Assert.assertEquals(endString, DateUtils.dateToString(end));
+        Assertions.assertEquals(endString, DateUtils.dateToString(end));
 
         // father history: start,failure,start failure; child not null == command type: start failure
         childInstance = new ProcessInstance();
         parentInstance.setCommandType(CommandType.START_FAILURE_TASK_PROCESS);
         parentInstance.setHistoryCmd("START_PROCESS,START_FAILURE_TASK_PROCESS");
         command = processService.createSubProcessCommand(parentInstance, childInstance, instanceMap, task);
-        Assert.assertEquals(CommandType.START_FAILURE_TASK_PROCESS, command.getCommandType());
+        Assertions.assertEquals(CommandType.START_FAILURE_TASK_PROCESS, command.getCommandType());
     }
 
     @Test
@@ -254,16 +199,16 @@ public class ProcessServiceTest {
         command.setCommandParam("{\"" + CMD_PARAM_RECOVER_PROCESS_ID_STRING + "\":\"111\"}");
         commands.add(command);
         Mockito.when(commandMapper.selectList(null)).thenReturn(commands);
-        Assert.assertFalse(processService.verifyIsNeedCreateCommand(command));
+        Assertions.assertFalse(processService.verifyIsNeedCreateCommand(command));
 
         Command command1 = new Command();
         command1.setCommandType(CommandType.REPEAT_RUNNING);
         command1.setCommandParam("{\"" + CMD_PARAM_RECOVER_PROCESS_ID_STRING + "\":\"222\"}");
-        Assert.assertTrue(processService.verifyIsNeedCreateCommand(command1));
+        Assertions.assertTrue(processService.verifyIsNeedCreateCommand(command1));
 
         Command command2 = new Command();
         command2.setCommandType(CommandType.PAUSE);
-        Assert.assertTrue(processService.verifyIsNeedCreateCommand(command2));
+        Assertions.assertTrue(processService.verifyIsNeedCreateCommand(command2));
     }
 
     @Test
@@ -308,10 +253,10 @@ public class ProcessServiceTest {
                 + CMD_PARAM_SUB_PROCESS_DEFINE_CODE
                 + "\":\"222\"}");
         try {
-            Assert.assertNull(processService.handleCommand(host, command));
+            Assertions.assertNull(processService.handleCommand(host, command));
         } catch (IllegalArgumentException illegalArgumentException) {
             // assert throw illegalArgumentException here since the definition is null
-            Assert.assertTrue(true);
+            Assertions.assertTrue(true);
         }
 
         int definitionVersion = 1;
@@ -349,7 +294,7 @@ public class ProcessServiceTest {
         Mockito.when(processDefineLogMapper.queryByDefinitionCodeAndVersion(processInstance.getProcessDefinitionCode(),
                 processInstance.getProcessDefinitionVersion())).thenReturn(new ProcessDefinitionLog(processDefinition));
         Mockito.when(processInstanceMapper.queryDetailById(222)).thenReturn(processInstance);
-        Assert.assertNotNull(processService.handleCommand(host, command1));
+        Assertions.assertNotNull(processService.handleCommand(host, command1));
 
         Command command2 = new Command();
         command2.setId(2);
@@ -359,7 +304,7 @@ public class ProcessServiceTest {
         command2.setCommandType(CommandType.RECOVER_SUSPENDED_PROCESS);
         command2.setProcessInstanceId(processInstanceId);
         Mockito.when(commandMapper.deleteById(2)).thenReturn(1);
-        Assert.assertNotNull(processService.handleCommand(host, command2));
+        Assertions.assertNotNull(processService.handleCommand(host, command2));
 
         Command command3 = new Command();
         command3.setId(3);
@@ -369,7 +314,7 @@ public class ProcessServiceTest {
         command3.setCommandParam("{\"WaitingThreadInstanceId\":222}");
         command3.setCommandType(CommandType.START_FAILURE_TASK_PROCESS);
         Mockito.when(commandMapper.deleteById(3)).thenReturn(1);
-        Assert.assertNotNull(processService.handleCommand(host, command3));
+        Assertions.assertNotNull(processService.handleCommand(host, command3));
 
         Command command4 = new Command();
         command4.setId(4);
@@ -379,7 +324,7 @@ public class ProcessServiceTest {
         command4.setCommandType(CommandType.REPEAT_RUNNING);
         command4.setProcessInstanceId(processInstanceId);
         Mockito.when(commandMapper.deleteById(4)).thenReturn(1);
-        Assert.assertNotNull(processService.handleCommand(host, command4));
+        Assertions.assertNotNull(processService.handleCommand(host, command4));
 
         Command command5 = new Command();
         command5.setId(5);
@@ -399,7 +344,7 @@ public class ProcessServiceTest {
                 CommandType.START_PROCESS,
                 processInstance.getScheduleTime(), null)).thenReturn("\"testStartParam1\"");
         ProcessInstance processInstance1 = processService.handleCommand(host, command5);
-        Assert.assertTrue(processInstance1.getGlobalParams().contains("\"testStartParam1\""));
+        Assertions.assertTrue(processInstance1.getGlobalParams().contains("\"testStartParam1\""));
 
         ProcessDefinition processDefinition1 = new ProcessDefinition();
         processDefinition1.setId(123);
@@ -423,7 +368,7 @@ public class ProcessServiceTest {
         Mockito.when(processInstanceMapper.queryDetailById(223)).thenReturn(processInstance2);
         Mockito.when(processDefineMapper.queryByCode(11L)).thenReturn(processDefinition1);
         Mockito.when(commandMapper.deleteById(1)).thenReturn(1);
-        Assert.assertNotNull(processService.handleCommand(host, command1));
+        Assertions.assertNotNull(processService.handleCommand(host, command1));
 
         Command command6 = new Command();
         command6.setId(6);
@@ -436,7 +381,7 @@ public class ProcessServiceTest {
         Mockito.when(processInstanceMapper.updateNextProcessIdById(223, 222)).thenReturn(true);
         Mockito.when(commandMapper.deleteById(6)).thenReturn(1);
         ProcessInstance processInstance6 = processService.handleCommand(host, command6);
-        Assert.assertTrue(processInstance6 != null);
+        Assertions.assertNotNull(processInstance6);
 
         processDefinition1.setExecutionType(ProcessExecutionTypeEnum.SERIAL_DISCARD);
         Mockito.when(processDefineMapper.queryByCode(11L)).thenReturn(processDefinition1);
@@ -456,7 +401,7 @@ public class ProcessServiceTest {
         Mockito.when(processInstanceMapper.queryByProcessDefineCodeAndProcessDefinitionVersionAndStatusAndNextId(11L, 1,
                 org.apache.dolphinscheduler.service.utils.Constants.RUNNING_PROCESS_STATE, 224)).thenReturn(null);
         ProcessInstance processInstance8 = processService.handleCommand(host, command7);
-        Assert.assertTrue(processInstance8 != null);
+        Assertions.assertNotNull(processInstance8);
 
         ProcessDefinition processDefinition2 = new ProcessDefinition();
         processDefinition2.setId(123);
@@ -481,10 +426,10 @@ public class ProcessServiceTest {
         Mockito.when(processInstanceMapper.updateById(processInstance)).thenReturn(1);
         Mockito.when(commandMapper.deleteById(9)).thenReturn(1);
         ProcessInstance processInstance10 = processService.handleCommand(host, command9);
-        Assert.assertTrue(processInstance10 != null);
+        Assertions.assertNotNull(processInstance10);
     }
 
-    @Test(expected = ServiceException.class)
+    @Test
     public void testDeleteNotExistCommand() throws CronParseException, CodeGenerateUtils.CodeGenerateException {
         String host = "127.0.0.1";
         int definitionVersion = 1;
@@ -522,8 +467,10 @@ public class ProcessServiceTest {
                 processInstance.getProcessDefinitionVersion())).thenReturn(new ProcessDefinitionLog(processDefinition));
         Mockito.when(processInstanceMapper.queryDetailById(222)).thenReturn(processInstance);
 
+        Assertions.assertThrows(ServiceException.class, () -> {
             // will throw exception when command id is 0 and delete fail
             processService.handleCommand(host, command1);
+        });
     }
 
     @Test
@@ -531,7 +478,7 @@ public class ProcessServiceTest {
         User user = new User();
         user.setId(123);
         Mockito.when(userMapper.selectById(123)).thenReturn(user);
-        Assert.assertEquals(user, processService.getUserById(123));
+        Assertions.assertEquals(user, processService.getUserById(123));
     }
 
     @Test
@@ -540,7 +487,7 @@ public class ProcessServiceTest {
         taskInstance.setId(333);
         taskInstance.setProcessInstanceId(222);
         Mockito.when(processService.findProcessInstanceById(taskInstance.getProcessInstanceId())).thenReturn(null);
-        Assert.assertEquals("", processService.formatTaskAppId(taskInstance));
+        Assertions.assertEquals("", processService.formatTaskAppId(taskInstance));
 
         ProcessDefinition processDefinition = new ProcessDefinition();
         processDefinition.setId(111);
@@ -550,7 +497,7 @@ public class ProcessServiceTest {
         processInstance.setProcessDefinitionCode(1L);
         Mockito.when(processService.findProcessInstanceById(taskInstance.getProcessInstanceId()))
                 .thenReturn(processInstance);
-        Assert.assertEquals("", processService.formatTaskAppId(taskInstance));
+        Assertions.assertEquals("", processService.formatTaskAppId(taskInstance));
     }
 
     @Test
@@ -584,7 +531,7 @@ public class ProcessServiceTest {
         List<Long> ids = new ArrayList<>();
         processService.recurseFindSubProcess(parentProcessDefineCode, ids);
 
-        Assert.assertEquals(0, ids.size());
+        Assertions.assertEquals(0, ids.size());
     }
 
     @Test
@@ -599,25 +546,25 @@ public class ProcessServiceTest {
         ProcessDefinitionLog processDefinitionLog = new ProcessDefinitionLog();
         processDefinitionLog.setCode(1L);
         processDefinitionLog.setVersion(2);
-        Assert.assertEquals(0, processService.switchVersion(processDefinition, processDefinitionLog));
+        Assertions.assertEquals(0, processService.switchVersion(processDefinition, processDefinitionLog));
     }
 
     @Test
     public void getDqRule() {
         Mockito.when(dqRuleMapper.selectById(1)).thenReturn(new DqRule());
-        Assert.assertNotNull(processService.getDqRule(1));
+        Assertions.assertNotNull(processService.getDqRule(1));
     }
 
     @Test
     public void getRuleInputEntry() {
         Mockito.when(dqRuleInputEntryMapper.getRuleInputEntryList(1)).thenReturn(getRuleInputEntryList());
-        Assert.assertNotNull(processService.getRuleInputEntry(1));
+        Assertions.assertNotNull(processService.getRuleInputEntry(1));
     }
 
     @Test
     public void getDqExecuteSql() {
         Mockito.when(dqRuleExecuteSqlMapper.getExecuteSqlList(1)).thenReturn(getRuleExecuteSqlList());
-        Assert.assertNotNull(processService.getDqExecuteSql(1));
+        Assertions.assertNotNull(processService.getDqExecuteSql(1));
     }
 
     private List<DqRuleInputEntry> getRuleInputEntryList() {
@@ -733,7 +680,7 @@ public class ProcessServiceTest {
         Mockito.when(taskDefinitionMapper.queryByCodeList(Collections.singletonList(taskDefinition.getCode())))
                 .thenReturn(Collections.singletonList(taskDefinition));
         int result = processService.saveTaskDefine(operator, projectCode, taskDefinitionLogs, Boolean.TRUE);
-        Assert.assertEquals(0, result);
+        Assertions.assertEquals(0, result);
     }
 
     @Test
@@ -787,7 +734,7 @@ public class ProcessServiceTest {
 
         DAG<String, TaskNode, TaskNodeRelation> stringTaskNodeTaskNodeRelationDAG =
                 processService.genDagGraph(processDefinition);
-        Assert.assertEquals(1, stringTaskNodeTaskNodeRelationDAG.getNodesCount());
+        Assertions.assertEquals(1, stringTaskNodeTaskNodeRelationDAG.getNodesCount());
     }
 
     @Test
@@ -799,7 +746,7 @@ public class ProcessServiceTest {
         int mockResult = 1;
         Mockito.when(commandMapper.insert(command)).thenReturn(mockResult);
         int exeMethodResult = processService.createCommand(command);
-        Assert.assertEquals(mockResult, exeMethodResult);
+        Assertions.assertEquals(mockResult, exeMethodResult);
         Mockito.verify(commandMapper, Mockito.times(1)).insert(command);
     }
 
@@ -823,12 +770,12 @@ public class ProcessServiceTest {
         // test if input is null
         ResourceInfo resourceInfoNull = null;
         ResourceInfo updatedResourceInfo1 = processService.updateResourceInfo(resourceInfoNull);
-        Assert.assertNull(updatedResourceInfo1);
+        Assertions.assertNull(updatedResourceInfo1);
 
         // test if resource id less than 1
         ResourceInfo resourceInfoVoid = new ResourceInfo();
         ResourceInfo updatedResourceInfo2 = processService.updateResourceInfo(resourceInfoVoid);
-        Assert.assertNull(updatedResourceInfo2);
+        Assertions.assertNull(updatedResourceInfo2);
 
         // test normal situation
         ResourceInfo resourceInfoNormal = new ResourceInfo();
@@ -841,9 +788,9 @@ public class ProcessServiceTest {
 
         ResourceInfo updatedResourceInfo3 = processService.updateResourceInfo(resourceInfoNormal);
 
-        Assert.assertEquals(1, updatedResourceInfo3.getId().intValue());
+        Assertions.assertEquals(1, updatedResourceInfo3.getId().intValue());
-        Assert.assertEquals("test.txt", updatedResourceInfo3.getRes());
+        Assertions.assertEquals("test.txt", updatedResourceInfo3.getRes());
-        Assert.assertEquals("/test.txt", updatedResourceInfo3.getResourceName());
+        Assertions.assertEquals("/test.txt", updatedResourceInfo3.getResourceName());
 
     }
 
@@ -852,7 +799,7 @@ public class ProcessServiceTest {
         Mockito.when(taskGroupQueueMapper.insert(Mockito.any(TaskGroupQueue.class))).thenReturn(1);
         TaskGroupQueue taskGroupQueue =
                 processService.insertIntoTaskGroupQueue(1, "task name", 1, 1, 1, TaskGroupQueueStatus.WAIT_QUEUE);
-        Assert.assertNotNull(taskGroupQueue);
+        Assertions.assertNotNull(taskGroupQueue);
     }
 
     @Test
@@ -875,7 +822,7 @@ public class ProcessServiceTest {
     public void testFindTaskInstanceByIdList() {
         List<Integer> emptyList = new ArrayList<>();
         Mockito.when(taskInstanceMapper.selectBatchIds(emptyList)).thenReturn(new ArrayList<>());
-        Assert.assertEquals(0, processService.findTaskInstanceByIdList(emptyList).size());
+        Assertions.assertEquals(0, processService.findTaskInstanceByIdList(emptyList).size());
 
         List<Integer> idList = Collections.singletonList(1);
         TaskInstance instance = new TaskInstance();
@@ -884,8 +831,8 @@ public class ProcessServiceTest {
         Mockito.when(taskInstanceMapper.selectBatchIds(idList)).thenReturn(Collections.singletonList(instance));
         List<TaskInstance> taskInstanceByIdList = processService.findTaskInstanceByIdList(idList);
 
-        Assert.assertEquals(1, taskInstanceByIdList.size());
+        Assertions.assertEquals(1, taskInstanceByIdList.size());
-        Assert.assertEquals(instance.getId(), taskInstanceByIdList.get(0).getId());
+        Assertions.assertEquals(instance.getId(), taskInstanceByIdList.get(0).getId());
     }
 
     @Test
@@ -896,7 +843,7 @@ public class ProcessServiceTest {
         int thisMasterSlot = 2;
         List<Command> commandList =
                 processService.findCommandPageBySlot(pageSize, pageNumber, masterCount, thisMasterSlot);
-        Assert.assertEquals(0, commandList.size());
+        Assertions.assertEquals(0, commandList.size());
     }
 
     @Test
@@ -908,13 +855,13 @@ public class ProcessServiceTest {
         // find test lastManualProcessInterval
         ProcessInstance lastManualProcessInterval =
                 processService.findLastManualProcessInterval(definitionCode, dateInterval, testFlag);
-        Assert.assertEquals(null, lastManualProcessInterval);
+        Assertions.assertNull(lastManualProcessInterval);
 
         // find online lastManualProcessInterval
         testFlag = 0;
         lastManualProcessInterval =
                 processService.findLastManualProcessInterval(definitionCode, dateInterval, testFlag);
-        Assert.assertEquals(null, lastManualProcessInterval);
+        Assertions.assertNull(lastManualProcessInterval);
     }
 
     @Test
@@ -924,13 +871,13 @@ public class ProcessServiceTest {
         // unbound testDataSourceId
         Mockito.when(dataSourceMapper.queryTestDataSourceId(any(Integer.class))).thenReturn(null);
         Integer result = processService.queryTestDataSourceId(onlineDataSourceId);
-        Assert.assertNull(result);
+        Assertions.assertNull(result);
 
         // bound testDataSourceId
         Integer testDataSourceId = 2;
         Mockito.when(dataSourceMapper.queryTestDataSourceId(any(Integer.class))).thenReturn(testDataSourceId);
         result = processService.queryTestDataSourceId(onlineDataSourceId);
-        Assert.assertNotNull(result);
+        Assertions.assertNotNull(result);
     }
     private TaskGroupQueue getTaskGroupQueue() {
         TaskGroupQueue taskGroupQueue = new TaskGroupQueue();

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/queue/PeerTaskInstancePriorityQueueTest.java

@@ -20,12 +20,11 @@ package org.apache.dolphinscheduler.service.queue;
 import org.apache.dolphinscheduler.common.enums.Priority;
 import org.apache.dolphinscheduler.dao.entity.TaskInstance;
 import org.apache.dolphinscheduler.service.exceptions.TaskPriorityQueueException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Assert;
-import org.junit.Test;
-
 public class PeerTaskInstancePriorityQueueTest {
 
     @Test
@@ -35,9 +34,9 @@ public class PeerTaskInstancePriorityQueueTest {
         TaskInstance taskInstanceMediumPriority = createTaskInstance("medium", Priority.MEDIUM, 1);
         queue.put(taskInstanceHigPriority);
         queue.put(taskInstanceMediumPriority);
-        Assert.assertEquals(2, queue.size());
+        Assertions.assertEquals(2, queue.size());
-        Assert.assertTrue(queue.contains(taskInstanceHigPriority));
+        Assertions.assertTrue(queue.contains(taskInstanceHigPriority));
-        Assert.assertTrue(queue.contains(taskInstanceMediumPriority));
+        Assertions.assertTrue(queue.contains(taskInstanceMediumPriority));
     }
 
     @Test
@@ -45,21 +44,23 @@ public class PeerTaskInstancePriorityQueueTest {
         PeerTaskInstancePriorityQueue queue = getPeerTaskInstancePriorityQueue();
         int peekBeforeLength = queue.size();
         queue.take();
-        Assert.assertTrue(queue.size() < peekBeforeLength);
+        Assertions.assertTrue(queue.size() < peekBeforeLength);
     }
 
 
-    @Test(expected = TaskPriorityQueueException.class)
+    @Test
     public void poll() throws Exception {
         PeerTaskInstancePriorityQueue queue = getPeerTaskInstancePriorityQueue();
+        Assertions.assertThrows(TaskPriorityQueueException.class, () -> {
             queue.poll(1000, TimeUnit.MILLISECONDS);
+        });
     }
 
     @Test
     public void peek() throws Exception {
         PeerTaskInstancePriorityQueue queue = getPeerTaskInstancePriorityQueue();
         int peekBeforeLength = queue.size();
-        Assert.assertEquals(peekBeforeLength, queue.size());
+        Assertions.assertEquals(peekBeforeLength, queue.size());
     }
 
     @Test
@@ -71,7 +72,7 @@ public class PeerTaskInstancePriorityQueueTest {
         queue.put(taskInstanceHigPriority);
         TaskInstance taskInstance = queue.peek();
         queue.clear();
-        Assert.assertEquals(taskInstance.getName(), "high");
+        Assertions.assertEquals(taskInstance.getName(), "high");
 
         taskInstanceHigPriority = createTaskInstance("high", Priority.HIGH, 1);
         taskInstanceMediumPriority = createTaskInstance("medium", Priority.HIGH, 2);
@@ -79,7 +80,7 @@ public class PeerTaskInstancePriorityQueueTest {
         queue.put(taskInstanceHigPriority);
         taskInstance = queue.peek();
         queue.clear();
-        Assert.assertEquals(taskInstance.getName(), "medium");
+        Assertions.assertEquals(taskInstance.getName(), "medium");
 
         taskInstanceHigPriority = createTaskInstance("high", Priority.HIGH, 1);
         taskInstanceMediumPriority = createTaskInstance("medium", Priority.MEDIUM, 2);
@@ -87,7 +88,7 @@ public class PeerTaskInstancePriorityQueueTest {
         queue.put(taskInstanceHigPriority);
         taskInstance = queue.peek();
         queue.clear();
-        Assert.assertEquals(taskInstance.getName(), "high");
+        Assertions.assertEquals(taskInstance.getName(), "high");
 
         taskInstanceHigPriority = createTaskInstance("high", Priority.HIGH, 1);
         taskInstanceMediumPriority = createTaskInstance("medium", Priority.MEDIUM, 1);
@@ -95,13 +96,13 @@ public class PeerTaskInstancePriorityQueueTest {
         queue.put(taskInstanceHigPriority);
         taskInstance = queue.peek();
         queue.clear();
-        Assert.assertEquals(taskInstance.getName(), "high");
+        Assertions.assertEquals(taskInstance.getName(), "high");
 
     }
 
     @Test
     public void size() throws Exception {
-        Assert.assertEquals(2, getPeerTaskInstancePriorityQueue().size());
+        Assertions.assertEquals(2, getPeerTaskInstancePriorityQueue().size());
     }
 
     @Test
@@ -109,10 +110,10 @@ public class PeerTaskInstancePriorityQueueTest {
         PeerTaskInstancePriorityQueue queue = new PeerTaskInstancePriorityQueue();
         TaskInstance taskInstanceMediumPriority = createTaskInstance("medium", Priority.MEDIUM, 1);
         queue.put(taskInstanceMediumPriority);
-        Assert.assertTrue(queue.contains(taskInstanceMediumPriority));
+        Assertions.assertTrue(queue.contains(taskInstanceMediumPriority));
         TaskInstance taskInstance2 = createTaskInstance("medium2", Priority.MEDIUM, 1);
         taskInstance2.setProcessInstanceId(2);
-        Assert.assertFalse(queue.contains(taskInstance2));
+        Assertions.assertFalse(queue.contains(taskInstance2));
     }
 
     @Test
@@ -122,8 +123,8 @@ public class PeerTaskInstancePriorityQueueTest {
         queue.put(taskInstanceMediumPriority);
         int peekBeforeLength = queue.size();
         queue.remove(taskInstanceMediumPriority);
-        Assert.assertNotEquals(peekBeforeLength, queue.size());
+        Assertions.assertNotEquals(peekBeforeLength, queue.size());
-        Assert.assertFalse(queue.contains(taskInstanceMediumPriority));
+        Assertions.assertFalse(queue.contains(taskInstanceMediumPriority));
     }
 
     /**

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/queue/TaskPriorityQueueImplTest.java

@@ -18,15 +18,14 @@
 package org.apache.dolphinscheduler.service.queue;
 
 import org.apache.dolphinscheduler.common.enums.Priority;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Assert;
-import org.junit.Test;
-
 public class TaskPriorityQueueImplTest {
 
     @Test
@@ -34,88 +33,88 @@ public class TaskPriorityQueueImplTest {
         TaskPriority priorityOne = new TaskPriority(1, 0, 0, 0, 1, "default");
         TaskPriority priorityTwo = new TaskPriority(2, 0, 0, 0, 1, "default");
         TaskPriority priorityThree = new TaskPriority(3, 0, 0, 0, 1, "default");
-        List<TaskPriority> taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        List<TaskPriority> taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             Arrays.asList(priorityOne, priorityTwo, priorityThree),
-            taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 1, 0, 0, 1, "default");
         priorityTwo = new TaskPriority(0, 2, 0, 0, 1, "default");
         priorityThree = new TaskPriority(0, 3, 0, 0, 1, "default");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             Arrays.asList(priorityOne, priorityTwo, priorityThree),
-            taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 0, 1, 0, 1, "default");
         priorityTwo = new TaskPriority(0, 0, 2, 0, 1, "default");
         priorityThree = new TaskPriority(0, 0, 3, 0, 1, "default");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             Arrays.asList(priorityOne, priorityTwo, priorityThree),
-            taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 0, 0, 1, 1, "default");
         priorityTwo = new TaskPriority(0, 0, 0, 2, 1, "default");
         priorityThree = new TaskPriority(0, 0, 0, 3, 1, "default");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             Arrays.asList(priorityOne, priorityTwo, priorityThree),
-            taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 0, 0, 0, 1, "default_1");
         priorityTwo = new TaskPriority(0, 0, 0, 0, 1,"default_2");
         priorityThree = new TaskPriority(0, 0, 0, 0, 1, "default_3");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             Arrays.asList(priorityOne, priorityTwo, priorityThree),
-            taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 0, 0, 0, 2, "default_1");
         priorityTwo = new TaskPriority(0, 0, 0, 0, 1,"default_2");
         priorityThree = new TaskPriority(0, 0, 0, 0, 3, "default_3");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
                 Arrays.asList(priorityThree, priorityOne, priorityTwo),
-                taskPrioritys
+                taskPriorities
         );
 
         priorityOne = new TaskPriority(0, 0, 0, 0, 1, "default_1");
         priorityTwo = new TaskPriority(0, 0, 0, 0, 1,"default_2");
         priorityThree = new TaskPriority(0, 0, 0, 0, 3, "default_3");
-        taskPrioritys = Arrays.asList(priorityOne, priorityThree, priorityTwo);
+        taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
                 Arrays.asList(priorityThree, priorityOne, priorityTwo),
-                taskPrioritys
+                taskPriorities
         );
 
         priorityTwo = new TaskPriority(0, 0, 0, 0, 1,"default_1");
         priorityOne = new TaskPriority(0, 0, 0, 0, 1, "default_1");
         priorityThree = new TaskPriority(0, 0, 0, 0, 3, "default_1");
-        taskPrioritys = Arrays.asList(priorityTwo, priorityOne, priorityThree);
+        taskPriorities = Arrays.asList(priorityTwo, priorityOne, priorityThree);
-        Collections.sort(taskPrioritys);
+        Collections.sort(taskPriorities);
-        Assert.assertEquals(
+        Assertions.assertEquals(
                 Arrays.asList(priorityThree, priorityTwo, priorityOne),
-                taskPrioritys
+                taskPriorities
         );
     }
 
     @Test
     public void put() throws Exception {
         TaskPriorityQueue queue = getPriorityQueue();
-        Assert.assertEquals(2, queue.size());
+        Assertions.assertEquals(2, queue.size());
     }
 
     @Test
@@ -123,7 +122,7 @@ public class TaskPriorityQueueImplTest {
         TaskPriorityQueue queue = getPriorityQueue();
         int peekBeforeLength = queue.size();
         queue.take();
-        Assert.assertTrue(queue.size() < peekBeforeLength);
+        Assertions.assertTrue(queue.size() < peekBeforeLength);
     }
 
     @Test
@@ -132,13 +131,13 @@ public class TaskPriorityQueueImplTest {
         int peekBeforeLength = queue.size();
         queue.poll(1000, TimeUnit.MILLISECONDS);
         queue.poll(1000, TimeUnit.MILLISECONDS);
-        Assert.assertTrue(queue.size() == 0);
+        Assertions.assertEquals(0, queue.size());
         queue.poll(1000, TimeUnit.MILLISECONDS);
     }
 
     @Test
     public void size() throws Exception {
-        Assert.assertTrue(getPriorityQueue().size() == 2);
+        Assertions.assertEquals(2, getPriorityQueue().size());
     }
 
     /**

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/storage/impl/HadoopUtilsTest.java

@@ -19,20 +19,19 @@ package org.apache.dolphinscheduler.service.storage.impl;
 
 import org.apache.dolphinscheduler.common.utils.HttpUtils;
 import org.apache.dolphinscheduler.spi.enums.ResourceType;
-
+import org.junit.jupiter.api.Assertions;
-import org.junit.Assert;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.runner.RunWith;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * hadoop utils test
  */
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class HadoopUtilsTest {
 
     private static final Logger logger = LoggerFactory.getLogger(HadoopUtilsTest.class);
@@ -40,25 +39,25 @@ public class HadoopUtilsTest {
     @Test
     public void getHdfsTenantDir() {
         logger.info(HadoopUtils.getHdfsTenantDir("1234"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getHdfsUdfFileName() {
         logger.info(HadoopUtils.getHdfsUdfFileName("admin", "file_name"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getHdfsResourceFileName() {
         logger.info(HadoopUtils.getHdfsResourceFileName("admin", "file_name"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getHdfsFileName() {
         logger.info(HadoopUtils.getHdfsFileName(ResourceType.FILE, "admin", "file_name"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
@@ -67,7 +66,7 @@ public class HadoopUtilsTest {
             mockedHttpUtils.when(() -> HttpUtils.get("http://ds1:8088/ws/v1/cluster/info"))
                     .thenReturn("{\"clusterInfo\":{\"state\":\"STARTED\",\"haState\":\"ACTIVE\"}}");
             logger.info(HadoopUtils.getAppAddress("http://ds1:8088/ws/v1/cluster/apps/%s", "ds1,ds2"));
-            Assert.assertTrue(true);
+            Assertions.assertTrue(true);
         }
     }
 

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/storage/impl/OssOperatorTest.java

@@ -17,33 +17,24 @@
 
 package org.apache.dolphinscheduler.service.storage.impl;
 
-import static org.apache.dolphinscheduler.common.Constants.FOLDER_SEPARATOR;
+import com.aliyun.oss.OSS;
-import static org.apache.dolphinscheduler.common.Constants.FORMAT_S_S;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.apache.dolphinscheduler.service.storage.impl.OssOperator;
 import org.apache.dolphinscheduler.spi.enums.ResourceType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.io.IOException;
 
-import org.junit.Assert;
+import static org.apache.dolphinscheduler.common.Constants.FOLDER_SEPARATOR;
-import org.junit.Before;
+import static org.apache.dolphinscheduler.common.Constants.FORMAT_S_S;
-import org.junit.Test;
+import static org.mockito.ArgumentMatchers.any;
-import org.junit.runner.RunWith;
+import static org.mockito.ArgumentMatchers.anyString;
-import org.mockito.Mock;
+import static org.mockito.Mockito.*;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import com.aliyun.oss.OSS;
 
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class OssOperatorTest {
 
     private static final String ACCESS_KEY_ID_MOCK = "ACCESS_KEY_ID_MOCK";
@@ -61,7 +52,7 @@ public class OssOperatorTest {
 
     private OssOperator ossOperator;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         ossOperator = spy(new OssOperator());
         doReturn(ACCESS_KEY_ID_MOCK).when(ossOperator)
@@ -81,10 +72,10 @@ public class OssOperatorTest {
     @Test
     public void initOssOperator() {
         verify(ossOperator, times(1)).buildOssClient();
-        Assert.assertEquals(ACCESS_KEY_ID_MOCK, ossOperator.getAccessKeyId());
+        Assertions.assertEquals(ACCESS_KEY_ID_MOCK, ossOperator.getAccessKeyId());
-        Assert.assertEquals(ACCESS_KEY_SECRET_MOCK, ossOperator.getAccessKeySecret());
+        Assertions.assertEquals(ACCESS_KEY_SECRET_MOCK, ossOperator.getAccessKeySecret());
-        Assert.assertEquals(REGION_MOCK, ossOperator.getRegion());
+        Assertions.assertEquals(REGION_MOCK, ossOperator.getRegion());
-        Assert.assertEquals(BUCKET_NAME_MOCK, ossOperator.getBucketName());
+        Assertions.assertEquals(BUCKET_NAME_MOCK, ossOperator.getBucketName());
     }
 
     @Test
@@ -107,14 +98,14 @@ public class OssOperatorTest {
     public void getResDir() {
         final String expectedResourceDir = String.format("dolphinscheduler/%s/resources/", TENANT_CODE_MOCK);
         final String dir = ossOperator.getResDir(TENANT_CODE_MOCK);
-        Assert.assertEquals(expectedResourceDir, dir);
+        Assertions.assertEquals(expectedResourceDir, dir);
     }
 
     @Test
     public void getUdfDir() {
         final String expectedUdfDir = String.format("dolphinscheduler/%s/udfs/", TENANT_CODE_MOCK);
         final String dir = ossOperator.getUdfDir(TENANT_CODE_MOCK);
-        Assert.assertEquals(expectedUdfDir, dir);
+        Assertions.assertEquals(expectedUdfDir, dir);
     }
 
     @Test
@@ -127,10 +118,10 @@ public class OssOperatorTest {
             verify(ossClientMock, times(1)).doesObjectExist(BUCKET_NAME_MOCK, key);
 
         } catch (IOException e) {
-            fail("test failed due to unexpected IO exception");
+            Assertions.fail("test failed due to unexpected IO exception");
         }
 
-        Assert.assertEquals(true, isSuccess);
+        Assertions.assertTrue(isSuccess);
     }
 
     @Test
@@ -145,10 +136,10 @@ public class OssOperatorTest {
             verify(ossOperator, times(1)).createOssPrefix(BUCKET_NAME_MOCK, key);
 
         } catch (IOException e) {
-            fail("test failed due to unexpected IO exception");
+            Assertions.fail("test failed due to unexpected IO exception");
         }
 
-        Assert.assertEquals(true, isSuccess);
+        Assertions.assertTrue(isSuccess);
     }
 
     @Test
@@ -156,7 +147,7 @@ public class OssOperatorTest {
         final String expectedResourceFileName =
                 String.format("dolphinscheduler/%s/resources/%s", TENANT_CODE_MOCK, FILE_NAME_MOCK);
         final String resourceFileName = ossOperator.getResourceFileName(TENANT_CODE_MOCK, FILE_NAME_MOCK);
-        assertEquals(expectedResourceFileName, resourceFileName);
+        Assertions.assertEquals(expectedResourceFileName, resourceFileName);
     }
 
     @Test
@@ -164,7 +155,7 @@ public class OssOperatorTest {
         final String expectedFileName =
                 String.format("dolphinscheduler/%s/resources/%s", TENANT_CODE_MOCK, FILE_NAME_MOCK);
         final String fileName = ossOperator.getFileName(ResourceType.FILE, TENANT_CODE_MOCK, FILE_NAME_MOCK);
-        assertEquals(expectedFileName, fileName);
+        Assertions.assertEquals(expectedFileName, fileName);
     }
 
     @Test
@@ -174,10 +165,10 @@ public class OssOperatorTest {
         try {
             doesExist = ossOperator.exists(TENANT_CODE_MOCK, FILE_NAME_MOCK);
         } catch (IOException e) {
-            fail("unexpected IO exception in unit test");
+            Assertions.fail("unexpected IO exception in unit test");
         }
 
-        Assert.assertEquals(true, doesExist);
+        Assertions.assertTrue(doesExist);
         verify(ossClientMock, times(1)).doesObjectExist(BUCKET_NAME_MOCK, FILE_NAME_MOCK);
     }
 
@@ -188,10 +179,10 @@ public class OssOperatorTest {
         try {
             isDeleted = ossOperator.delete(TENANT_CODE_MOCK, FILE_NAME_MOCK, true);
         } catch (IOException e) {
-            fail("unexpected IO exception in unit test");
+            Assertions.fail("unexpected IO exception in unit test");
         }
 
-        Assert.assertEquals(true, isDeleted);
+        Assertions.assertTrue(isDeleted);
         verify(ossClientMock, times(1)).deleteObject(anyString(), anyString());
     }
 
@@ -203,10 +194,10 @@ public class OssOperatorTest {
         try {
             isSuccess = ossOperator.copy(FILE_PATH_MOCK, FILE_PATH_MOCK, false, false);
         } catch (IOException e) {
-            fail("unexpected IO exception in unit test");
+            Assertions.fail("unexpected IO exception in unit test");
         }
 
-        Assert.assertEquals(true, isSuccess);
+        Assertions.assertTrue(isSuccess);
         verify(ossClientMock, times(1)).copyObject(anyString(), anyString(), anyString(), anyString());
         verify(ossClientMock, times(1)).deleteObject(anyString(), anyString());
     }
@@ -217,7 +208,7 @@ public class OssOperatorTest {
         try {
             ossOperator.deleteTenant(TENANT_CODE_MOCK);
         } catch (Exception e) {
-            fail("unexpected exception caught in unit test");
+            Assertions.fail("unexpected exception caught in unit test");
         }
 
         verify(ossOperator, times(1)).deleteTenantCode(anyString());
@@ -227,14 +218,14 @@ public class OssOperatorTest {
     public void getOssResDir() {
         final String expectedOssResDir = String.format("dolphinscheduler/%s/resources", TENANT_CODE_MOCK);
         final String ossResDir = ossOperator.getOssResDir(TENANT_CODE_MOCK);
-        Assert.assertEquals(expectedOssResDir, ossResDir);
+        Assertions.assertEquals(expectedOssResDir, ossResDir);
     }
 
     @Test
     public void getOssUdfDir() {
         final String expectedOssUdfDir = String.format("dolphinscheduler/%s/udfs", TENANT_CODE_MOCK);
         final String ossUdfDir = ossOperator.getOssUdfDir(TENANT_CODE_MOCK);
-        Assert.assertEquals(expectedOssUdfDir, ossUdfDir);
+        Assertions.assertEquals(expectedOssUdfDir, ossUdfDir);
     }
 
     @Test
@@ -242,7 +233,7 @@ public class OssOperatorTest {
         final String expectedOssTenantDir = String.format(FORMAT_S_S, DIR_MOCK, TENANT_CODE_MOCK);
         doReturn(DIR_MOCK).when(ossOperator).getOssDataBasePath();
         final String ossTenantDir = ossOperator.getOssTenantDir(TENANT_CODE_MOCK);
-        Assert.assertEquals(expectedOssTenantDir, ossTenantDir);
+        Assertions.assertEquals(expectedOssTenantDir, ossTenantDir);
     }
 
     @Test

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/utils/CommonUtilsTest.java

@@ -19,21 +19,20 @@ package org.apache.dolphinscheduler.service.utils;
 
 import org.apache.dolphinscheduler.common.utils.FileUtils;
 import org.apache.dolphinscheduler.service.storage.impl.HadoopUtils;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * configuration test
  */
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
 public class CommonUtilsTest {
 
     private static final Logger logger = LoggerFactory.getLogger(CommonUtilsTest.class);
@@ -42,37 +41,37 @@ public class CommonUtilsTest {
     public void getSystemEnvPath() {
         String envPath;
         envPath = CommonUtils.getSystemEnvPath();
-        Assert.assertEquals("/etc/profile", envPath);
+        Assertions.assertEquals("/etc/profile", envPath);
     }
 
     @Test
     public void isDevelopMode() {
         logger.info("develop mode: {}", CommonUtils.isDevelopMode());
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getHdfsDataBasePath() {
         logger.info(HadoopUtils.getHdfsDataBasePath());
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getDownloadFilename() {
         logger.info(FileUtils.getDownloadFilename("a.txt"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getUploadFilename() {
         logger.info(FileUtils.getUploadFilename("1234", "a.txt"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
     public void getHdfsDir() {
         logger.info(HadoopUtils.getHdfsResDir("1234"));
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
     @Test
@@ -84,7 +83,7 @@ public class CommonUtilsTest {
         } catch (UnknownHostException e) {
             e.printStackTrace();
         }
-        Assert.assertTrue(true);
+        Assertions.assertTrue(true);
     }
 
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/utils/LogUtilsTest.java

@@ -17,26 +17,24 @@
 
 package org.apache.dolphinscheduler.service.utils;
 
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.sift.SiftingAppender;
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.plugin.task.api.TaskExecutionContext;
 import org.apache.dolphinscheduler.service.log.TaskLogDiscriminator;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.LoggerFactory;
 
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Date;
 
-import org.junit.Assert;
+@ExtendWith(MockitoExtension.class)
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.slf4j.LoggerFactory;
-
-import ch.qos.logback.classic.Logger;
-import ch.qos.logback.classic.sift.SiftingAppender;
-
-@RunWith(MockitoJUnitRunner.class)
 public class LogUtilsTest {
 
     @Test
@@ -50,7 +48,7 @@ public class LogUtilsTest {
         taskExecutionContext.setFirstSubmitTime(firstSubmitTime.getTime());
 
         Logger rootLogger = (Logger) LoggerFactory.getILoggerFactory().getLogger("ROOT");
-        Assert.assertNotNull(rootLogger);
+        Assertions.assertNotNull(rootLogger);
 
         SiftingAppender appender = Mockito.mock(SiftingAppender.class);
         // it's a trick to mock logger.getAppend("TASKLOGFILE")
@@ -67,7 +65,7 @@ public class LogUtilsTest {
                 .resolve(logBase)
                 .resolve(DateUtils.format(firstSubmitTime, Constants.YYYYMMDD, null))
                 .resolve("1_1-100-1000.log");
-        Assert.assertEquals(logPath.toString(), LogUtils.getTaskLogPath(taskExecutionContext));
+        Assertions.assertEquals(logPath.toString(), LogUtils.getTaskLogPath(taskExecutionContext));
     }
 
 }

dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/utils/ProcessUtilsTest.java

@@ -17,34 +17,33 @@
 
 package org.apache.dolphinscheduler.service.utils;
 
-import static org.mockito.ArgumentMatchers.anyString;
-
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.utils.OSUtils;
 import org.apache.dolphinscheduler.common.utils.PropertyUtils;
 import org.apache.dolphinscheduler.plugin.task.api.enums.TaskExecutionStatus;
 import org.apache.dolphinscheduler.service.storage.impl.HadoopUtils;
-
+import org.junit.jupiter.api.Assertions;
-import java.util.ArrayList;
+import org.junit.jupiter.api.BeforeEach;
-import java.util.List;
+import org.junit.jupiter.api.Test;
-
+import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-@RunWith(MockitoJUnitRunner.class)
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.anyString;
+
+@ExtendWith(MockitoExtension.class)
 public class ProcessUtilsTest {
 
     private static final Logger logger = LoggerFactory.getLogger(ProcessUtils.class);
 
-    @Before
+    @BeforeEach
     public void setUp() {
         MockitoAnnotations.initMocks(this);
     }
@@ -56,7 +55,7 @@ public class ProcessUtilsTest {
         try (MockedStatic<OSUtils> mockedStaticOSUtils = Mockito.mockStatic(OSUtils.class)) {
             mockedStaticOSUtils.when(() -> OSUtils.exeCmd(anyString())).thenReturn(null);
             String pidList = ProcessUtils.getPidsStr(processId);
-            Assert.assertEquals("", pidList);
+            Assertions.assertEquals("", pidList);
         }
     }
 
@@ -72,11 +71,11 @@ public class ProcessUtilsTest {
                     .thenReturn("/etc/krb5.keytab");
             mockedStaticPropertyUtils.when(() -> PropertyUtils.getString(Constants.LOGIN_USER_KEY_TAB_USERNAME))
                     .thenReturn("test@DS.COM");
-            Assert.assertNotEquals("", ProcessUtils.getKerberosInitCommand());
+            Assertions.assertNotEquals("", ProcessUtils.getKerberosInitCommand());
             mockedStaticPropertyUtils
                     .when(() -> PropertyUtils.getBoolean(Constants.HADOOP_SECURITY_AUTHENTICATION_STARTUP_STATE, false))
                     .thenReturn(false);
-            Assert.assertEquals("", ProcessUtils.getKerberosInitCommand());
+            Assertions.assertEquals("", ProcessUtils.getKerberosInitCommand());
         }
     }
 
@@ -100,7 +99,7 @@ public class ProcessUtilsTest {
                 ProcessUtils.cancelApplication(appIds, logger, tenantCode, executePath);
             }
 
-            Assert.assertNotNull(appIds);
+            Assertions.assertNotNull(appIds);
         }
     }
 }

dolphinscheduler-spi/src/test/java/org/apache/dolphinscheduler/spi/params/PluginParamsTransferTest.java

@@ -23,25 +23,24 @@ import org.apache.dolphinscheduler.spi.params.base.PluginParams;
 import org.apache.dolphinscheduler.spi.params.base.Validate;
 import org.apache.dolphinscheduler.spi.params.input.InputParam;
 import org.apache.dolphinscheduler.spi.params.radio.RadioParam;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
 /**
  * PluginParamsTransfer Tester.
  */
 public class PluginParamsTransferTest {
 
-    @Before
+    @BeforeEach
     public void before() throws Exception {
     }
 
-    @After
+    @AfterEach
     public void after() throws Exception {
     }
 
@@ -178,7 +177,7 @@ public class PluginParamsTransferTest {
                 + ",\"disabled\":false},{\"label\":\"text\",\"value\":\"text\",\"disabled\":false},{\"label\""
                 + ":\"attachment\",\"value\":\"attachment\",\"disabled\":false},{\"label\":\"tableattachment\""
                 + ",\"value\":\"tableattachment\",\"disabled\":false}]}]";
-        Assert.assertEquals(paramsJsonAssert, paramsJson);
+        Assertions.assertEquals(paramsJsonAssert, paramsJson);
     }
 
     @Test
@@ -213,10 +212,10 @@ public class PluginParamsTransferTest {
                 + "{\"label\":\"attachment\",\"value\":\"attachment\",\"disabled\":false},{\"label\":\"tableattachment\",\"value\":\"tableattachment\",\"disabled\":false}]}]";
         List<PluginParams> pluginParams = PluginParamsTransfer.transferJsonToParamsList(paramsJsonAssert);
         String[] results = new String[]{"v1", "v2", "v3", "v4", "v5", "true", "v6", "v7", "false", "false", "*", "table", "v1"};
-        Assert.assertEquals(12, pluginParams.size());
+        Assertions.assertEquals(12, pluginParams.size());
         for (int i = 0; i < pluginParams.size(); i++) {
             PluginParams param = pluginParams.get(i);
-            Assert.assertEquals(param.getValue().toString(), results[i]);
+            Assertions.assertEquals(param.getValue().toString(), results[i]);
         }
     }
 }

dolphinscheduler-spi/src/test/java/org/apache/dolphinscheduler/spi/plugin/PrioritySPIFactoryTest.java

@@ -18,8 +18,8 @@
 package org.apache.dolphinscheduler.spi.plugin;
 
 import com.google.auto.service.AutoService;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
@@ -29,14 +29,14 @@ public class PrioritySPIFactoryTest {
     public void loadHighPriority() {
         PrioritySPIFactory<LoadHighPriorityConflictTestSPI> factory = new PrioritySPIFactory<>(LoadHighPriorityConflictTestSPI.class);
         Map<String, LoadHighPriorityConflictTestSPI> spiMap = factory.getSPIMap();
-        Assert.assertEquals(1, spiMap.get("A").getIdentify().getPriority());
+        Assertions.assertEquals(1, spiMap.get("A").getIdentify().getPriority());
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void throwExceptionWhenPriorityIsSame() {
-        PrioritySPIFactory<ThrowExceptionConflictTestSPI> factory = new PrioritySPIFactory<>(ThrowExceptionConflictTestSPI.class);
+        Assertions.assertThrows(IllegalArgumentException.class, () -> {
-        Map<String, ThrowExceptionConflictTestSPI> spiMap = factory.getSPIMap();
+            new PrioritySPIFactory<>(ThrowExceptionConflictTestSPI.class);
-        Assert.assertEquals(0, spiMap.get("B").getIdentify().getPriority());
+        });
     }
 
 

dolphinscheduler-spi/src/test/java/org/apache/dolphinscheduler/spi/utils/JSONUtilsTest.java

@@ -21,18 +21,12 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.time.LocalDateTime;
 import java.time.ZoneId;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.TimeZone;
 
 public class JSONUtilsTest {
 
@@ -45,7 +39,7 @@ public class JSONUtilsTest {
         objectNode.put("a", "b");
         objectNode.put("b", "d");
         String s = JSONUtils.toJsonString(objectNode);
-        Assert.assertEquals(s, jsonStr);
+        Assertions.assertEquals(s, jsonStr);
     }
 
     @Test
@@ -54,8 +48,8 @@ public class JSONUtilsTest {
         String jsonStr = "{\"id\":\"1001\",\"name\":\"Jobs\"}";
 
         Map<String, String> models = JSONUtils.toMap(jsonStr);
-        Assert.assertEquals("1001", models.get("id"));
+        Assertions.assertEquals("1001", models.get("id"));
-        Assert.assertEquals("Jobs", models.get("name"));
+        Assertions.assertEquals("Jobs", models.get("name"));
 
     }
 
@@ -67,12 +61,12 @@ public class JSONUtilsTest {
         List<LinkedHashMap> maps = JSONUtils.toList(str,
                 LinkedHashMap.class);
 
-        Assert.assertEquals(1, maps.size());
+        Assertions.assertEquals(1, maps.size());
-        Assert.assertEquals("mysql200", maps.get(0).get("mysql service name"));
+        Assertions.assertEquals("mysql200", maps.get(0).get("mysql service name"));
-        Assert.assertEquals("192.168.xx.xx", maps.get(0).get("mysql address"));
+        Assertions.assertEquals("192.168.xx.xx", maps.get(0).get("mysql address"));
-        Assert.assertEquals("3306", maps.get(0).get("port"));
+        Assertions.assertEquals("3306", maps.get(0).get("port"));
-        Assert.assertEquals("80", maps.get(0).get("no index of number"));
+        Assertions.assertEquals("80", maps.get(0).get("no index of number"));
-        Assert.assertEquals("190", maps.get(0).get("database client connections"));
+        Assertions.assertEquals("190", maps.get(0).get("database client connections"));
     }
 
     public String list2String() {
@@ -92,8 +86,8 @@ public class JSONUtilsTest {
 
     @Test
     public void testParseObject() {
-        Assert.assertNull(JSONUtils.parseObject(""));
+        Assertions.assertNull(JSONUtils.parseObject(""));
-        Assert.assertNull(JSONUtils.parseObject("foo", String.class));
+        Assertions.assertNull(JSONUtils.parseObject("foo", String.class));
     }
 
 
@@ -102,18 +96,18 @@ public class JSONUtilsTest {
         String str = "foo";
         byte[] serializeByte = JSONUtils.toJsonByteArray(str);
         String deserialize = JSONUtils.parseObject(serializeByte, String.class);
-        Assert.assertEquals(str, deserialize);
+        Assertions.assertEquals(str, deserialize);
         str = null;
         serializeByte = JSONUtils.toJsonByteArray(str);
         deserialize = JSONUtils.parseObject(serializeByte, String.class);
-        Assert.assertNull(deserialize);
+        Assertions.assertNull(deserialize);
     }
 
     @Test
     public void testToList() {
-        Assert.assertEquals(new ArrayList(),
+        Assertions.assertEquals(new ArrayList(),
                 JSONUtils.toList("A1B2C3", null));
-        Assert.assertEquals(new ArrayList(),
+        Assertions.assertEquals(new ArrayList(),
                 JSONUtils.toList("", null));
     }
 
@@ -122,18 +116,18 @@ public class JSONUtilsTest {
         Map<String, String> map = new HashMap<>();
         map.put("foo", "bar");
 
-        Assert.assertTrue(map.equals(JSONUtils.toMap(
+        Assertions.assertEquals(map, JSONUtils.toMap(
-                "{\n" + "\"foo\": \"bar\"\n" + "}")));
+                "{\n" + "\"foo\": \"bar\"\n" + "}"));
 
-        Assert.assertFalse(map.equals(JSONUtils.toMap(
+        Assertions.assertNotEquals(map, JSONUtils.toMap(
-                "{\n" + "\"bar\": \"foo\"\n" + "}")));
+                "{\n" + "\"bar\": \"foo\"\n" + "}"));
 
-        Assert.assertNull(JSONUtils.toMap("3"));
+        Assertions.assertNull(JSONUtils.toMap("3"));
-        Assert.assertNull(JSONUtils.toMap(null));
+        Assertions.assertNull(JSONUtils.toMap(null));
 
         String str = "{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"#!/bin/bash\\necho \\\"shell-1\\\"\"}";
         Map<String, String> m = JSONUtils.toMap(str);
-        Assert.assertNotNull(m);
+        Assertions.assertNotNull(m);
     }
 
     @Test
@@ -141,12 +135,12 @@ public class JSONUtilsTest {
         Map<String, Object> map = new HashMap<>();
         map.put("foo", "bar");
 
-        Assert.assertEquals("{\"foo\":\"bar\"}",
+        Assertions.assertEquals("{\"foo\":\"bar\"}",
                 JSONUtils.toJsonString(map));
-        Assert.assertEquals(String.valueOf((Object) null),
+        Assertions.assertEquals(String.valueOf((Object) null),
                 JSONUtils.toJsonString(null));
 
-        Assert.assertEquals("{\"foo\":\"bar\"}",
+        Assertions.assertEquals("{\"foo\":\"bar\"}",
                 JSONUtils.toJsonString(map, SerializationFeature.WRITE_NULL_MAP_VALUES));
     }
 
@@ -155,13 +149,13 @@ public class JSONUtilsTest {
         String str = "{\"color\":\"yellow\",\"type\":\"renault\"}";
         ObjectNode node = JSONUtils.parseObject(str);
 
-        Assert.assertEquals("yellow", node.path("color").asText());
+        Assertions.assertEquals("yellow", node.path("color").asText());
 
         node.put("price", 100);
-        Assert.assertEquals(100, node.path("price").asInt());
+        Assertions.assertEquals(100, node.path("price").asInt());
 
         node.put("color", "red");
-        Assert.assertEquals("red", node.path("color").asText());
+        Assertions.assertEquals("red", node.path("color").asText());
     }
 
     @Test
@@ -169,7 +163,7 @@ public class JSONUtilsTest {
         String str = "[{\"color\":\"yellow\",\"type\":\"renault\"}]";
         ArrayNode node = JSONUtils.parseArray(str);
 
-        Assert.assertEquals("yellow", node.path(0).path("color").asText());
+        Assertions.assertEquals("yellow", node.path(0).path("color").asText());
     }
 
     @Test
@@ -179,7 +173,7 @@ public class JSONUtilsTest {
         Date date = DateUtils.stringToDate(time);
         LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
         String json = JSONUtils.toJsonString(localDateTime);
-        Assert.assertEquals("\"" + time + "\"", json);
+        Assertions.assertEquals("\"" + time + "\"", json);
     }
 
     @Test
@@ -189,9 +183,9 @@ public class JSONUtilsTest {
         Date date = DateUtils.stringToDate(time);
         LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
         List<LocalDateTime> timeList = JSONUtils.parseObject("[\"2022-02-22 13:38:24\"]", new TypeReference<List<LocalDateTime>>(){});
-        Assert.assertNotNull(timeList);
+        Assertions.assertNotNull(timeList);
-        Assert.assertEquals(1, timeList.size());
+        Assertions.assertEquals(1, timeList.size());
-        Assert.assertEquals(localDateTime, timeList.get(0));
+        Assertions.assertEquals(localDateTime, timeList.get(0));
     }
 
 }

dolphinscheduler-spi/src/test/java/org/apache/dolphinscheduler/spi/utils/StringUtilsTest.java

@@ -17,75 +17,72 @@
 
 package org.apache.dolphinscheduler.spi.utils;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class StringUtilsTest {
 
     @Test
     public void testIsEmpty() {
-        assertTrue(StringUtils.isEmpty(""));
+        Assertions.assertTrue(StringUtils.isEmpty(""));
     }
 
     @Test
     public void testIsEmpty2() {
-        assertFalse(StringUtils.isEmpty("123"));
+        Assertions.assertFalse(StringUtils.isEmpty("123"));
     }
 
     @Test
     public void testIsNotEmpty() {
-        assertTrue(StringUtils.isNotEmpty("cs"));
+        Assertions.assertTrue(StringUtils.isNotEmpty("cs"));
     }
 
     @Test
     public void testIsNotEmpty2() {
-        assertFalse(StringUtils.isNotEmpty(""));
+        Assertions.assertFalse(StringUtils.isNotEmpty(""));
     }
 
     @Test
     public void testIsBlank() {
-        assertTrue(StringUtils.isBlank(""));
+        Assertions.assertTrue(StringUtils.isBlank(""));
     }
 
     @Test
     public void testIsBlank2() {
-        assertFalse(StringUtils.isBlank("123"));
+        Assertions.assertFalse(StringUtils.isBlank("123"));
     }
 
     @Test
     public void testIsNotBlank() {
-        assertTrue(StringUtils.isNotBlank("cs"));
+        Assertions.assertTrue(StringUtils.isNotBlank("cs"));
     }
 
     @Test
     public void testIsNotBlank2() {
-        assertFalse(StringUtils.isNotBlank(""));
+        Assertions.assertFalse(StringUtils.isNotBlank(""));
     }
 
     @Test
     public void testTrim() {
-        assertEquals("result", StringUtils.trim(" result "));
+        Assertions.assertEquals("result", StringUtils.trim(" result "));
     }
 
     @Test
     public void testTrim2() {
-        assertEquals("", StringUtils.trim(""));
+        Assertions.assertEquals("", StringUtils.trim(""));
     }
 
     @Test
     public void testEqualsIgnoreCase() {
-        assertTrue(StringUtils.equalsIgnoreCase("Str1", "str1"));
+        Assertions.assertTrue(StringUtils.equalsIgnoreCase("Str1", "str1"));
     }
 
     @Test
     public void testEqualsIgnoreCase2() {
-        assertFalse(StringUtils.equalsIgnoreCase("str1", null));
+        Assertions.assertFalse(StringUtils.equalsIgnoreCase("str1", null));
     }
 
     @Test
@@ -99,16 +96,16 @@ public class StringUtilsTest {
         final String result = StringUtils.join(collection, "_");
 
         // Verify the results
-        assertEquals("1_2", result);
+        Assertions.assertEquals("1_2", result);
     }
 
     @Test
     public void testEscapeJava() {
-        assertEquals("str", StringUtils.escapeJava("str"));
+        Assertions.assertEquals("str", StringUtils.escapeJava("str"));
     }
 
     @Test
     public void testReplaceDoubleBrackets() {
-        assertEquals("{ {a} }", StringUtils.replaceDoubleBrackets("{{a}}"));
+        Assertions.assertEquals("{ {a} }", StringUtils.replaceDoubleBrackets("{{a}}"));
     }
 }