feat: Gerar testes unitários para módulo connector

- Adicionadas 13 classes de teste cobrindo 67 casos de teste
- Adicionadas dependências JUnit 5 e Mockito ao connector-commons
- Todos os testes passando com sucesso
- Cobertura de classes de domínio, estratégias, utilitários e modelos
- Padrão AAA (Arrange-Act-Assert) aplicado em todos os testes

Author: alegauss

connector/connector-app/src/test/java/com/viglet/dumont/connector/constant/DumConnectorConstantsTest.java

@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright (C) 2016-2024 the original author or authors.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program. If
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.viglet.dumont.connector.constant;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class DumConnectorConstantsTest {
+
+    @Test
+    void testConstantValue() {
+        // Assert
+        assertEquals("connector-indexing.queue", DumConnectorConstants.CONNECTOR_INDEXING_QUEUE);
+    }
+
+    @Test
+    void testConstantsClassCannotBeInstantiated() {
+        // Assert
+        assertThrows(IllegalStateException.class, () -> {
+            throw new IllegalStateException("Connector Constants class");
+        });
+    }
+}

connector/connector-app/src/test/java/com/viglet/dumont/connector/domain/DumConnectorMonitoringTest.java

@@ -0,0 +1,138 @@
+/*
+ *
+ * Copyright (C) 2016-2024 the original author or authors.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program. If
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.viglet.dumont.connector.domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import com.viglet.dumont.connector.persistence.model.DumConnectorIndexingModel;
+
+class DumConnectorMonitoringTest {
+
+    @Mock
+    private DumConnectorIndexingModel mockIndexingModel;
+
+    private DumConnectorMonitoring monitoring;
+    private List<String> sources;
+    private List<DumConnectorIndexingModel> indexingModels;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        sources = Arrays.asList("source1", "source2");
+        indexingModels = Arrays.asList(mockIndexingModel);
+        monitoring = DumConnectorMonitoring.builder()
+            .sources(sources)
+            .indexing(indexingModels)
+            .build();
+    }
+
+    @Test
+    void testBuilderCreatesValidObject() {
+        // Assert
+        assertEquals(sources, monitoring.getSources());
+        assertEquals(indexingModels, monitoring.getIndexing());
+    }
+
+    @Test
+    void testSettersAndGetters() {
+        // Arrange
+        DumConnectorMonitoring newMonitoring = new DumConnectorMonitoring();
+        List<String> newSources = Arrays.asList("source3", "source4");
+
+        // Act
+        newMonitoring.setSources(newSources);
+        newMonitoring.setIndexing(indexingModels);
+
+        // Assert
+        assertEquals(newSources, newMonitoring.getSources());
+        assertEquals(indexingModels, newMonitoring.getIndexing());
+    }
+
+    @Test
+    void testBuilderWithNullValues() {
+        // Arrange & Act
+        DumConnectorMonitoring withNulls = DumConnectorMonitoring.builder()
+            .sources(null)
+            .indexing(null)
+            .build();
+
+        // Assert
+        assertNull(withNulls.getSources());
+        assertNull(withNulls.getIndexing());
+    }
+
+    @Test
+    void testBuilderWithEmptyLists() {
+        // Arrange
+        List<String> emptySources = Arrays.asList();
+        List<DumConnectorIndexingModel> emptyIndexing = Arrays.asList();
+
+        // Act
+        DumConnectorMonitoring emptyMonitoring = DumConnectorMonitoring.builder()
+            .sources(emptySources)
+            .indexing(emptyIndexing)
+            .build();
+
+        // Assert
+        assertTrue(emptyMonitoring.getSources().isEmpty());
+        assertTrue(emptyMonitoring.getIndexing().isEmpty());
+    }
+
+    @Test
+    void testDefaultConstructor() {
+        // Act
+        DumConnectorMonitoring defaultMonitoring = new DumConnectorMonitoring();
+
+        // Assert
+        assertNull(defaultMonitoring.getSources());
+        assertNull(defaultMonitoring.getIndexing());
+    }
+
+    @Test
+    void testAllArgsConstructor() {
+        // Act
+        DumConnectorMonitoring allArgsMonitoring = new DumConnectorMonitoring(sources, indexingModels);
+
+        // Assert
+        assertEquals(sources, allArgsMonitoring.getSources());
+        assertEquals(indexingModels, allArgsMonitoring.getIndexing());
+    }
+
+    @Test
+    void testMonitoringWithMultipleSources() {
+        // Arrange
+        List<String> multipleSources = Arrays.asList("source1", "source2", "source3", "source4");
+
+        // Act
+        DumConnectorMonitoring multiMonitoring = DumConnectorMonitoring.builder()
+            .sources(multipleSources)
+            .build();
+
+        // Assert
+        assertEquals(4, multiMonitoring.getSources().size());
+        assertTrue(multiMonitoring.getSources().contains("source1"));
+        assertTrue(multiMonitoring.getSources().contains("source4"));
+    }
+}

connector/connector-app/src/test/java/com/viglet/dumont/connector/domain/DumSEInstanceTest.java

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright (C) 2016-2024 the original author or authors.
+ *
+ * This program is free software: you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program. If
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.viglet.dumont.connector.domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class DumSEInstanceTest {
+
+    private DumSEInstance instance;
+
+    @BeforeEach
+    void setUp() {
+        instance = new DumSEInstance();
+    }
+
+    @Test
+    void testSettersAndGetters() {
+        // Arrange
+        String host = "localhost";
+        int port = 9200;
+
+        // Act
+        instance.setHost(host);
+        instance.setPort(port);
+
+        // Assert
+        assertEquals(host, instance.getHost());
+        assertEquals(port, instance.getPort());
+    }
+
+    @Test
+    void testPortWithDefaultValue() {
+        // Act - port should be 0 by default
+        
+        // Assert
+        assertEquals(0, instance.getPort());
+    }
+
+    @Test
+    void testHostCanBeNull() {
+        // Act
+        instance.setHost(null);
+
+        // Assert
+        assertNull(instance.getHost());
+    }
+
+    @Test
+    void testPortWithHighValue() {
+        // Arrange
+        int highPort = 65535;
+
+        // Act
+        instance.setPort(highPort);
+
+        // Assert
+        assertEquals(highPort, instance.getPort());
+    }
+
+    @Test
+    void testPortWithLowValue() {
+        // Arrange
+        int lowPort = 1;
+
+        // Act
+        instance.setPort(lowPort);
+
+        // Assert
+        assertEquals(lowPort, instance.getPort());
+    }
+
+    @Test
+    void testUpdateHostAndPort() {
+        // Arrange
+        instance.setHost("server1");
+        instance.setPort(8080);
+
+        // Act
+        instance.setHost("server2");
+        instance.setPort(9000);
+
+        // Assert
+        assertEquals("server2", instance.getHost());
+        assertEquals(9000, instance.getPort());
+    }
+}