MODWRKFLOW-18: Add component model unit tests.

components/src/main/test/java/org/folio/rest/workflow/model/AbstractGatewayTest.java

@@ -0,0 +1,38 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.folio.rest.workflow.model.AbstractGateway;
+import org.folio.rest.workflow.enums.Direction;
+import org.folio.rest.workflow.model.Node;
+
+public class AbstractGatewayTest {
+
+    private AbstractGateway abstractGateway;
+
+    @BeforeEach
+    void setUp() {
+        abstractGateway = new AbstractGateway();
+    }
+
+    @Test
+    void testConstructor() {
+        assertEquals(Direction.UNSPECIFIED, abstractGateway.getDirection());
+        assertNotNull(abstractGateway.getNodes());
+    }
+
+    @Test
+    void testDirectionGetterSetter() {
+        abstractGateway.setDirection(Direction.IN);
+        assertEquals(Direction.IN, abstractGateway.getDirection());
+    }
+
+    @Test
+    void testNodesGetterSetter() {
+        Node node = new Node();
+        abstractGateway.getNodes().add(node);
+        assertEquals(1, abstractGateway.getNodes().size());
+    }
+
+}

components/src/main/test/java/org/folio/rest/workflow/model/CompressFileTaskTest.java

@@ -0,0 +1,69 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.HashSet;
+import java.util.Set;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CompressFileTaskTest {
+
+    private CompressFileTask compressFileTask;
+
+    @BeforeEach
+    void setUp() {
+        compressFileTask = new CompressFileTask();
+    }
+
+    @Test
+    void testInputVariablesGetterSetter() {
+        Set<EmbeddedVariable> inputVariables = new HashSet<>();
+        inputVariables.add(new EmbeddedVariable("inputVar1", "value1"));
+        inputVariables.add(new EmbeddedVariable("inputVar2", "value2"));
+        compressFileTask.setInputVariables(inputVariables);
+        assertEquals(inputVariables, compressFileTask.getInputVariables());
+    }
+
+    @Test
+    void testOutputVariableGetterSetter() {
+        EmbeddedVariable outputVariable = new EmbeddedVariable("outputVar", "outputValue");
+        compressFileTask.setOutputVariable(outputVariable);
+        assertEquals(outputVariable, compressFileTask.getOutputVariable());
+    }
+
+    @Test
+    void testAsyncBeforeGetterSetter() {
+        compressFileTask.setAsyncBefore(true);
+        assertTrue(compressFileTask.isAsyncBefore());
+    }
+
+    @Test
+    void testAsyncAfterGetterSetter() {
+        compressFileTask.setAsyncAfter(true);
+        assertTrue(compressFileTask.isAsyncAfter());
+    }
+
+    @Test
+    void testSourceGetterSetter() {
+        compressFileTask.setSource("/path/to/source");
+        assertEquals("/path/to/source", compressFileTask.getSource());
+    }
+
+    @Test
+    void testDestinationGetterSetter() {
+        compressFileTask.setDestination("/path/to/destination");
+        assertEquals("/path/to/destination", compressFileTask.getDestination());
+    }
+
+    @Test
+    void testFormatGetterSetter() {
+        compressFileTask.setFormat(CompressFileFormat.ZIP);
+        assertEquals(CompressFileFormat.ZIP, compressFileTask.getFormat());
+    }
+
+    @Test
+    void testContainerGetterSetter() {
+        compressFileTask.setContainer(CompressFileContainer.TAR);
+        assertEquals(CompressFileContainer.TAR, compressFileTask.getContainer());
+    }
+}

components/src/main/test/java/org/folio/rest/workflow/model/ConditionTest.java

@@ -0,0 +1,67 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+import javax.validation.constraints.Size;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class ConditionTest {
+
+    private Condition condition;
+    private Validator validator;
+
+    @BeforeEach
+    void setUp() {
+        condition = new Condition();
+        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+        validator = factory.getValidator();
+    }
+
+    @Test
+    void testExpressionGetterSetter() {
+        String expression = "expression";
+        condition.setExpression(expression);
+        assertEquals(expression, condition.getExpression());
+    }
+
+    @Test
+    void testAnswerGetterSetter() {
+        String answer = "answer";
+        condition.setAnswer(answer);
+        assertEquals(answer, condition.getAnswer());
+    }
+
+    @Test
+    void testExpressionSizeValidation() {
+        assertThrows(Exception.class, () -> {
+            condition.setExpression("");
+            validator.validateProperty(condition, "expression");
+        });
+
+        assertThrows(Exception.class, () -> {
+            condition.setExpression("A".repeat(129));
+            validator.validateProperty(condition, "expression");
+        });
+
+        condition.setExpression("A".repeat(4));
+        assertEquals(0, validator.validateProperty(condition, "expression").size());
+    }
+
+    @Test
+    void testAnswerSizeValidation() {
+        assertThrows(Exception.class, () -> {
+            condition.setAnswer("");
+            validator.validateProperty(condition, "answer");
+        });
+
+        assertThrows(Exception.class, () -> {
+            condition.setAnswer("A".repeat(65));
+            validator.validateProperty(condition, "answer");
+        });
+
+        condition.setAnswer("A".repeat(2));
+        assertEquals(0, validator.validateProperty(condition, "answer").size());
+    }
+}

components/src/main/test/java/org/folio/rest/workflow/model/ConnectToTest.java

@@ -0,0 +1,36 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+import javax.validation.constraints.NotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class ConnectToTest {
+
+    private ConnectTo connectTo;
+    private Validator validator;
+
+    @BeforeEach
+    void setUp() {
+        connectTo = new ConnectTo();
+        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+        validator = factory.getValidator();
+    }
+
+    @Test
+    void testNodeIdGetterSetter() {
+        String nodeId = "nodeId";
+        connectTo.setNodeId(nodeId);
+        assertEquals(nodeId, connectTo.getNodeId());
+    }
+
+    @Test
+    void testNotNullConstraint() {
+        assertThrows(Exception.class, () -> {
+            connectTo.setNodeId(null);
+            validator.validateProperty(connectTo, "nodeId");
+        });
+    }
+}

components/src/main/test/java/org/folio/rest/workflow/model/Constants.java

@@ -0,0 +1,5 @@
+package org.folio.rest.workflow;
+
+public class Constants {
+
+}

components/src/main/test/java/org/folio/rest/workflow/model/DatabaseConnectionTaskTest.java

@@ -0,0 +1,72 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.HashSet;
+import java.util.Set;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+public class DatabaseConnectionTaskTest {
+
+    private DatabaseConnectionTask databaseConnectionTask;
+
+    @BeforeEach
+    void setUp() {
+        databaseConnectionTask = new DatabaseConnectionTask();
+    }
+
+    @Test
+    void testInputVariablesGetterSetter() {
+        Set<EmbeddedVariable> inputVariables = new HashSet<>();
+        inputVariables.add(new EmbeddedVariable("inputVar1", "value1"));
+        inputVariables.add(new EmbeddedVariable("inputVar2", "value2"));
+        databaseConnectionTask.setInputVariables(inputVariables);
+        assertEquals(inputVariables, databaseConnectionTask.getInputVariables());
+    }
+
+    @Test
+    void testOutputVariableGetterSetter() {
+        EmbeddedVariable outputVariable = new EmbeddedVariable("outputVar", "outputValue");
+        databaseConnectionTask.setOutputVariable(outputVariable);
+        assertEquals(outputVariable, databaseConnectionTask.getOutputVariable());
+    }
+
+    @Test
+    void testAsyncBeforeGetterSetter() {
+        databaseConnectionTask.setAsyncBefore(true);
+        assertEquals(true, databaseConnectionTask.isAsyncBefore());
+    }
+
+    @Test
+    void testAsyncAfterGetterSetter() {
+        databaseConnectionTask.setAsyncAfter(true);
+        assertEquals(true, databaseConnectionTask.isAsyncAfter());
+    }
+
+    @Test
+    void testDesignationGetterSetter() {
+        String designation = "designation";
+        databaseConnectionTask.setDesignation(designation);
+        assertEquals(designation, databaseConnectionTask.getDesignation());
+    }
+
+    @Test
+    void testUrlGetterSetter() {
+        String url = "url";
+        databaseConnectionTask.setUrl(url);
+        assertEquals(url, databaseConnectionTask.getUrl());
+    }
+
+    @Test
+    void testUsernameGetterSetter() {
+        String username = "username";
+        databaseConnectionTask.setUsername(username);
+        assertEquals(username, databaseConnectionTask.getUsername());
+    }
+
+    @Test
+    void testPasswordGetterSetter() {
+        String password = "password";
+        databaseConnectionTask.setPassword(password);
+        assertEquals(password, databaseConnectionTask.getPassword());
+    }
+}

components/src/main/test/java/org/folio/rest/workflow/model/DatabaseDisconnectTaskTest.java

@@ -0,0 +1,51 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.HashSet;
+import java.util.Set;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+public class DatabaseDisconnectTaskTest {
+
+    private DatabaseDisconnectTask databaseDisconnectTask;
+
+    @BeforeEach
+    void setUp() {
+        databaseDisconnectTask = new DatabaseDisconnectTask();
+    }
+
+    @Test
+    void testInputVariablesGetterSetter() {
+        Set<EmbeddedVariable> inputVariables = new HashSet<>();
+        inputVariables.add(new EmbeddedVariable("inputVar1", "value1"));
+        inputVariables.add(new EmbeddedVariable("inputVar2", "value2"));
+        databaseDisconnectTask.setInputVariables(inputVariables);
+        assertEquals(inputVariables, databaseDisconnectTask.getInputVariables());
+    }
+
+    @Test
+    void testOutputVariableGetterSetter() {
+        EmbeddedVariable outputVariable = new EmbeddedVariable("outputVar", "outputValue");
+        databaseDisconnectTask.setOutputVariable(outputVariable);
+        assertEquals(outputVariable, databaseDisconnectTask.getOutputVariable());
+    }
+
+    @Test
+    void testAsyncBeforeGetterSetter() {
+        databaseDisconnectTask.setAsyncBefore(true);
+        assertEquals(true, databaseDisconnectTask.isAsyncBefore());
+    }
+
+    @Test
+    void testAsyncAfterGetterSetter() {
+        databaseDisconnectTask.setAsyncAfter(true);
+        assertEquals(true, databaseDisconnectTask.isAsyncAfter());
+    }
+
+    @Test
+    void testDesignationGetterSetter() {
+        String designation = "designation";
+        databaseDisconnectTask.setDesignation(designation);
+        assertEquals(designation, databaseDisconnectTask.getDesignation());
+    }
+}