test/DolphinScheduler
1
0
Fork 0
mirror of https://gitee.com/dolphinscheduler/DolphinScheduler.git synced 2024-12-02 04:08:31 +08:00
Code Issues Actions 10 Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Yann Ann 2022-10-14 11:06:29 +08:00 committed by GitHub
parent c50cc997a8
commit b357781df2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 720 additions and 841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
dolphinscheduler-common/src/test/java/org/apache/dolphinscheduler/common/ConstantsTest.java
View File

@ -18,9 +18,8 @@
package org.apache.dolphinscheduler.common;
import org.apache.commons.lang3.SystemUtils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.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");
}
}

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

@ -18,8 +18,8 @@
package org.apache.dolphinscheduler.common.exception;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
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());
Assert.assertNotNull(new BaseException(message).getMessage());
Assert.assertNotNull(new BaseException(message, time).getMessage());
Assert.assertNotNull(new BaseException(time).getCause());
Assert.assertNotNull(new BaseException(message, time, false, false).getMessage());
Assertions.assertNull(new BaseException().getMessage());
Assertions.assertNotNull(new BaseException(message).getMessage());
Assertions.assertNotNull(new BaseException(message, time).getMessage());
Assertions.assertNotNull(new BaseException(time).getCause());
Assertions.assertNotNull(new BaseException(message, time, false, false).getMessage());
Assert.assertNull(new StorageOperateNoConfiguredException().getMessage());
Assert.assertNotNull(new StorageOperateNoConfiguredException(message).getMessage());
Assert.assertNotNull(new StorageOperateNoConfiguredException(message, time).getMessage());
Assert.assertNotNull(new StorageOperateNoConfiguredException(time).getCause());
Assert.assertNotNull(new StorageOperateNoConfiguredException(message, time, false, false).getMessage());
Assertions.assertNull(new StorageOperateNoConfiguredException().getMessage());
Assertions.assertNotNull(new StorageOperateNoConfiguredException(message).getMessage());
Assertions.assertNotNull(new StorageOperateNoConfiguredException(message, time).getMessage());
Assertions.assertNotNull(new StorageOperateNoConfiguredException(time).getCause());
Assertions.assertNotNull(new StorageOperateNoConfiguredException(message, time, false, false).getMessage());
}
}

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

@ -16,9 +16,10 @@
*/
package org.apache.dolphinscheduler.common.graph;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
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 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);
assertEquals(graph.getEdgesCount(), 6);
Assertions.assertEquals(graph.getNodesCount(), 7);
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)");
assertTrue(graph.containsNode(1));
Assertions.assertEquals(graph.getNode(1), "v(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));
assertEquals(graph.getEdgesCount(), 1);
Assertions.assertTrue(graph.containsEdge(1, 2));
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);
assertEquals(graph.getIndegree(2), 1);
assertEquals(graph.getIndegree(3), 0);
assertEquals(graph.getIndegree(4), 0);
Assertions.assertEquals(graph.getIndegree(1), 0);
Assertions.assertEquals(graph.getIndegree(2), 1);
Assertions.assertEquals(graph.getIndegree(3), 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));
assertTrue(graph.getBeginNode().contains(3));
assertTrue(graph.getBeginNode().contains(4));
Assertions.assertTrue(graph.getBeginNode().contains(1));
Assertions.assertTrue(graph.getBeginNode().contains(3));
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));
assertTrue(graph.addEdge(3, 4));
Assertions.assertTrue(graph.addEdge(2, 5));
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));
assertTrue(graph.addEdge(6, 8));
Assertions.assertTrue(graph.addEdge(6, 7));
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"));
}
}

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

@ -16,17 +16,15 @@
*/
package org.apache.dolphinscheduler.common.os;
import org.apache.dolphinscheduler.common.utils.OSUtils;
import org.apache.commons.lang3.SystemUtils;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.apache.dolphinscheduler.common.utils.OSUtils;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.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"));
Assert.assertFalse(userList.contains("xxxtt"));
Assertions.assertTrue(userList.contains("root"));
Assertions.assertFalse(userList.contains("xxxtt"));
} else {
Assert.assertFalse("system must be linux", false);
Assertions.assertFalse(false, "system must be linux");
}

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

@ -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 org.junit.Test;
import java.util.HashSet;
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);
}
}

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

@ -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);
Assert.assertEquals(sunday, sunday1);
Assertions.assertEquals(monday, monday1);
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");
Assert.assertEquals(DateUtils.dateToString(DateUtils.getSomeDay(d1, -31)), "2018-12-31 00:00:00");
Assertions.assertEquals(DateUtils.dateToString(curr), "2019-02-01 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));
Assert.assertEquals(TimeZone.getTimeZone("MST"), DateUtils.getTimezone("MST"));
Assertions.assertNull(DateUtils.getTimezone(null));
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);
}
}

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

@ -16,8 +16,8 @@
*/
package org.apache.dolphinscheduler.common.utils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
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(""));
}
}

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

@ -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 org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.apache.dolphinscheduler.common.Constants.YYYYMMDDHHMMSS;
@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));
}
}

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

@ -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.Assert;
import org.junit.jupiter.api.Assertions;
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);
}
}

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

@ -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));
assertEquals("127.0.0.1:5678", NetUtils.getAddr("127.0.0.1", 5678));
assertEquals("localhost:1234", NetUtils.getAddr("localhost", 1234));
Assertions.assertEquals(NetUtils.getHost() + ":5678", NetUtils.getAddr(5678));
Assertions.assertEquals("127.0.0.1:5678", NetUtils.getAddr("127.0.0.1", 5678));
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));
}
}

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

@ -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.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.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());
}
}

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

@ -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.Test;
import org.junit.jupiter.api.Assertions;
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]);
Assert.assertTrue(result);
Assertions.assertEquals(finalExecTarget, execTime[0]);
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());
Assert.assertEquals(3, execTime[0]);
Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
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]);
Assert.assertFalse(result);
Assertions.assertEquals(1, execTime[0]);
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]);
Assert.assertTrue(result);
Assertions.assertEquals(finalExecTarget, execTime[0]);
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());
Assert.assertEquals(3, execTime[0]);
Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
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]);
Assert.assertTrue(result);
Assertions.assertEquals(finalExecTarget, execTime[0]);
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());
Assert.assertEquals(3, execTime[0]);
Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
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]);
Assert.assertFalse(result);
Assertions.assertEquals(1, execTime[0]);
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]);
Assert.assertTrue(result);
Assertions.assertEquals(finalExecTarget, execTime[0]);
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());
Assert.assertEquals(3, execTime[0]);
Assert.assertNotNull(e.getCause());
Assert.assertEquals(3, Integer.parseInt(e.getCause().getMessage()));
Assertions.assertEquals(3, e.getNumberOfFailedAttempts());
Assertions.assertEquals(3, execTime[0]);
Assertions.assertNotNull(e.getCause());
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());
}
}

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

@ -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 org.junit.Test;
import java.io.StringReader;
public class ScriptRunnerTest {
@Test
@ -32,6 +32,6 @@ public class ScriptRunnerTest {
} catch (Exception e) {
exception = e;
}
Assert.assertNotNull(exception);
Assertions.assertNotNull(exception);
}
}

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

@ -16,8 +16,8 @@
*/
package org.apache.dolphinscheduler.common.utils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
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);
}
}
}

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

@ -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 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.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
@RunWith(MockitoJUnitRunner.class)
@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()));

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

@ -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 org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
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;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* ProcessAlertManager Test
*/
@RunWith(MockitoJUnitRunner.class)
@ExtendWith(MockitoExtension.class)
public class ProcessAlertManagerTest {
private static final Logger logger = LoggerFactory.getLogger(ProcessAlertManagerTest.class);

24
dolphinscheduler-service/src/test/java/org/apache/dolphinscheduler/service/cache/CacheNotifyServiceTest.java vendored
View File

@ -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 org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.ArrayList;
import java.util.List;
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;
/**
* 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();

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

@ -17,36 +17,26 @@
package org.apache.dolphinscheduler.service.cron;
import static com.cronutils.model.field.expression.FieldExpressionFactory.always;
import static com.cronutils.model.field.expression.FieldExpressionFactory.every;
import static com.cronutils.model.field.expression.FieldExpressionFactory.on;
import static com.cronutils.model.field.expression.FieldExpressionFactory.questionMark;
import org.apache.dolphinscheduler.common.enums.CycleEnum;
import org.apache.dolphinscheduler.common.utils.DateUtils;
import org.apache.dolphinscheduler.service.exceptions.CronParseException;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Date;
import org.junit.Assert;
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;
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 static com.cronutils.model.field.expression.FieldExpressionFactory.*;
/**
* 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());
Assert.assertEquals("1", depCron.retrieve(CronFieldName.MINUTE).getExpression().asString());
Assert.assertEquals("2", depCron.retrieve(CronFieldName.HOUR).getExpression().asString());
Assert.assertEquals("3", depCron.retrieve(CronFieldName.DAY_OF_MONTH).getExpression().asString());
Assert.assertEquals("*", depCron.retrieve(CronFieldName.MONTH).getExpression().asString());
Assert.assertEquals("*", depCron.retrieve(CronFieldName.YEAR).getExpression().asString());
Assertions.assertEquals("0", depCron.retrieve(CronFieldName.SECOND).getExpression().asString());
Assertions.assertEquals("1", depCron.retrieve(CronFieldName.MINUTE).getExpression().asString());
Assertions.assertEquals("2", depCron.retrieve(CronFieldName.HOUR).getExpression().asString());
Assertions.assertEquals("3", depCron.retrieve(CronFieldName.DAY_OF_MONTH).getExpression().asString());
Assertions.assertEquals("*", depCron.retrieve(CronFieldName.MONTH).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());
Assert.assertEquals(5, CronUtils.getSelfFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? "), 5).size());
Assertions.assertEquals(30, CronUtils.getFireDateList(from, to, CronUtils.parse2Cron("0 0 0 * * ? ")).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));
}
}

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

@ -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.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
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.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.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
@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);
Assert.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(result);
Assertions.assertNull(dolphinSchedulerCuringGlobalParams.curingGlobalParams(1, null, null, CommandType.START_CURRENT_TASK_PROCESS, null, 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"));
}
}

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

@ -18,14 +18,14 @@
package org.apache.dolphinscheduler.service.expand;
import org.apache.commons.lang3.StringUtils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
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));
}
}

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

@ -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 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.nio.charset.StandardCharsets;
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;
@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);
}
}
}

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

@ -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.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
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 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();
loggerRequestProcessor.process(channel, command);
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();
loggerRequestProcessor.process(channel, command);
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();
loggerRequestProcessor.process(channel, command);
Assertions.assertThrows(IllegalArgumentException.class, () -> {
loggerRequestProcessor.process(channel, command);
});
}
}

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

@ -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);
}
}

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

@ -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 org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.apache.dolphinscheduler.service.log.SensitiveDataConverter.passwordHandler;
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));
Assert.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
Assertions.assertNotEquals(logMsg, passwordHandler(pwdPattern, logMsg));
Assertions.assertEquals(maskLogMsg, passwordHandler(pwdPattern, logMsg));
}

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

@ -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

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

@ -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);
}
}

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

@ -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);
}
}

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

@ -17,65 +17,18 @@
package org.apache.dolphinscheduler.service.process;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING;
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 com.fasterxml.jackson.databind.JsonNode;
import org.apache.dolphinscheduler.common.Constants;
import org.apache.dolphinscheduler.common.enums.CommandType;
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.enums.*;
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.DqExecuteResult;
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.entity.*;
import org.apache.dolphinscheduler.dao.mapper.*;
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.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.enums.dp.*;
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 java.util.ArrayList;
import java.util.Collections;
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.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
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 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));
Assert.assertEquals(endString, DateUtils.dateToString(end));
Assertions.assertEquals(startString, DateUtils.dateToString(start));
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);
// will throw exception when command id is 0 and delete fail
processService.handleCommand(host, command1);
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());
Assert.assertEquals("test.txt", updatedResourceInfo3.getRes());
Assert.assertEquals("/test.txt", updatedResourceInfo3.getResourceName());
Assertions.assertEquals(1, updatedResourceInfo3.getId().intValue());
Assertions.assertEquals("test.txt", updatedResourceInfo3.getRes());
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());
Assert.assertEquals(instance.getId(), taskInstanceByIdList.get(0).getId());
Assertions.assertEquals(1, taskInstanceByIdList.size());
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();

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

@ -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());
Assert.assertTrue(queue.contains(taskInstanceHigPriority));
Assert.assertTrue(queue.contains(taskInstanceMediumPriority));
Assertions.assertEquals(2, queue.size());
Assertions.assertTrue(queue.contains(taskInstanceHigPriority));
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();
queue.poll(1000, TimeUnit.MILLISECONDS);
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());
Assert.assertFalse(queue.contains(taskInstanceMediumPriority));
Assertions.assertNotEquals(peekBeforeLength, queue.size());
Assertions.assertFalse(queue.contains(taskInstanceMediumPriority));
}
/**

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

@ -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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
List<TaskPriority> taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityOne, priorityThree, priorityTwo);
Collections.sort(taskPriorities);
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);
Collections.sort(taskPrioritys);
Assert.assertEquals(
taskPriorities = Arrays.asList(priorityTwo, priorityOne, priorityThree);
Collections.sort(taskPriorities);
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());
}
/**

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

@ -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.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
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.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);
}
}

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

@ -17,33 +17,24 @@
package org.apache.dolphinscheduler.service.storage.impl;
import static org.apache.dolphinscheduler.common.Constants.FOLDER_SEPARATOR;
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 com.aliyun.oss.OSS;
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 org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.apache.dolphinscheduler.common.Constants.FOLDER_SEPARATOR;
import static org.apache.dolphinscheduler.common.Constants.FORMAT_S_S;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;
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());
Assert.assertEquals(ACCESS_KEY_SECRET_MOCK, ossOperator.getAccessKeySecret());
Assert.assertEquals(REGION_MOCK, ossOperator.getRegion());
Assert.assertEquals(BUCKET_NAME_MOCK, ossOperator.getBucketName());
Assertions.assertEquals(ACCESS_KEY_ID_MOCK, ossOperator.getAccessKeyId());
Assertions.assertEquals(ACCESS_KEY_SECRET_MOCK, ossOperator.getAccessKeySecret());
Assertions.assertEquals(REGION_MOCK, ossOperator.getRegion());
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

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

@ -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);
}
}

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

@ -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;
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)
@ExtendWith(MockitoExtension.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));
}
}

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

@ -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 org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.mockito.ArgumentMatchers.anyString;
@RunWith(MockitoJUnitRunner.class)
@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);
}
}
}

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

@ -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]);
}
}
}

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

@ -18,8 +18,8 @@
package org.apache.dolphinscheduler.spi.plugin;
import com.google.auto.service.AutoService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
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);
Map<String, ThrowExceptionConflictTestSPI> spiMap = factory.getSPIMap();
Assert.assertEquals(0, spiMap.get("B").getIdentify().getPriority());
Assertions.assertThrows(IllegalArgumentException.class, () -> {
new PrioritySPIFactory<>(ThrowExceptionConflictTestSPI.class);
});
}

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

@ -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.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.*;
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"));
Assert.assertEquals("Jobs", models.get("name"));
Assertions.assertEquals("1001", models.get("id"));
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());
Assert.assertEquals("mysql200", maps.get(0).get("mysql service name"));
Assert.assertEquals("192.168.xx.xx", maps.get(0).get("mysql address"));
Assert.assertEquals("3306", maps.get(0).get("port"));
Assert.assertEquals("80", maps.get(0).get("no index of number"));
Assert.assertEquals("190", maps.get(0).get("database client connections"));
Assertions.assertEquals(1, maps.size());
Assertions.assertEquals("mysql200", maps.get(0).get("mysql service name"));
Assertions.assertEquals("192.168.xx.xx", maps.get(0).get("mysql address"));
Assertions.assertEquals("3306", maps.get(0).get("port"));
Assertions.assertEquals("80", maps.get(0).get("no index of number"));
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(""));
Assert.assertNull(JSONUtils.parseObject("foo", String.class));
Assertions.assertNull(JSONUtils.parseObject(""));
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(
"{\n" + "\"foo\": \"bar\"\n" + "}")));
Assertions.assertEquals(map, JSONUtils.toMap(
"{\n" + "\"foo\": \"bar\"\n" + "}"));
Assert.assertFalse(map.equals(JSONUtils.toMap(
"{\n" + "\"bar\": \"foo\"\n" + "}")));
Assertions.assertNotEquals(map, JSONUtils.toMap(
"{\n" + "\"bar\": \"foo\"\n" + "}"));
Assert.assertNull(JSONUtils.toMap("3"));
Assert.assertNull(JSONUtils.toMap(null));
Assertions.assertNull(JSONUtils.toMap("3"));
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);
Assert.assertEquals(1, timeList.size());
Assert.assertEquals(localDateTime, timeList.get(0));
Assertions.assertNotNull(timeList);
Assertions.assertEquals(1, timeList.size());
Assertions.assertEquals(localDateTime, timeList.get(0));
}
}

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

@ -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}}"));
}
}