AggregatorTests migrated and working, now starting to clean-improve e…

…veruthing.

retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorTests.java

@@ -0,0 +1,82 @@
+package giis.retorch.orchestration;
+
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.classic.spi.LoggingEvent;
+import ch.qos.logback.core.Appender;
+import giis.retorch.orchestration.model.TGroup;
+import giis.retorch.orchestration.scheduler.NotValidSystemException;
+import giis.retorch.orchestration.scheduler.RetorchAggregator;
+import giis.retorch.orchestration.model.System;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
+public class AggregatorTests {
+
+    private final Appender<ILoggingEvent>  appender = mock(Appender.class);
+    private final Logger logger = (Logger) LoggerFactory.getLogger(RetorchAggregator.class);
+    private RetorchAggregator aggregator;
+    private AggregatorUtils utils;
+    private System baseSystem;
+    private final org.slf4j.Logger log = LoggerFactory.getLogger(this.getClass());
+    @Before
+    public void setUp() {
+        log.debug("Starting the setup");
+        utils = new AggregatorUtils();
+        logger.addAppender(appender);
+            log.debug("Ending the setup");
+    }
+
+    @Test
+    public void testUnitArchIAggValidTGroup() throws NotValidSystemException, IOException {
+        baseSystem = utils.generateSystemAggregator();
+        aggregator = new RetorchAggregator(baseSystem);
+        List<TGroup> tGroupsOutputAggregator = aggregator.generateTGroups();
+        List<TGroup> expectedTGroups = utils.getExpectedTGroups();
+        Assert.assertEquals(expectedTGroups, tGroupsOutputAggregator);
+    }
+
+    @Test
+    public void testUnitArchAggInvalidTGroup() throws NotValidSystemException, IOException {
+        baseSystem = utils.getInvalidSystemAggregator();
+        aggregator = new RetorchAggregator(baseSystem);
+        ArgumentCaptor<LoggingEvent> argument = ArgumentCaptor.forClass(LoggingEvent.class);
+        verify(appender, atLeast(2)).doAppend(argument.capture());
+        List<LoggingEvent> listEvents = argument.getAllValues();
+        List<String> listMessages = listEvents.stream().map(LoggingEvent::getMessage).collect(Collectors.toList());
+        //Checks that all the resources provided are required by a test case.
+        //Checks that all test cases have the required resources in the system
+        assertEquals("The test case  TCNoRequired requires the resources: [res{InventedResource'," +
+                " p=[], r=[], elas{'InventedResourceelasModel', e=2, cost=50.0}, LOGICAL,null}] any of them doesn't exist " +
+                "in the system",listMessages.get(1));
+        //Checks a repeated resource (invalid)
+        assertEquals("There are several repeated Test Cases in the System " +
+                "InvalidSystem:[tSevenAgg]",listMessages.get(0));
+    }
+
+    @Test
+    public void testUnitArchAggInvalidEmptyTGroups() throws NotValidSystemException, IOException {
+        baseSystem = utils.generateSystemAggregator();
+        aggregator = new RetorchAggregator(new System("EmptySystem"));
+        ArgumentCaptor<LoggingEvent> argument = ArgumentCaptor.forClass(LoggingEvent.class);
+        verify(appender, atLeast(2)).doAppend(argument.capture());
+        List<LoggingEvent> listEvents = argument.getAllValues();
+        List<String> listMessages = listEvents.stream().map(LoggingEvent::getMessage).collect(Collectors.toList());
+        //Omission of attributes in the accessMode
+        //Check that the omitted AccessMode is detected
+        assertEquals(4,listMessages.size());
+        assertEquals("The number of resources in the system EmptySystem is zero",listMessages.get(0));
+        assertEquals("The number of test cases in the system EmptySystem is zero",listMessages.get(1));
+    }
+}

retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorUtils.java

@@ -0,0 +1,276 @@
+package giis.retorch.orchestration;
+
+import giis.retorch.orchestration.classifier.ResourceSerializer;
+import giis.retorch.orchestration.model.*;
+import giis.retorch.orchestration.model.System;
+import giis.retorch.orchestration.testdata.AggregatorClassTests;
+
+
+import java.io.IOException;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class AggregatorUtils extends GenericUtils {
+
+    protected static final String MEDIUM_INELASTIC_ID = "MedInElasRest";
+    private static AccessMode getAccessModeClass() {
+        AccessMode accessResourceThatNotExist = new AccessMode();
+        accessResourceThatNotExist.setType(new AccessModeTypes("READONLY"));
+        accessResourceThatNotExist.setConcurrency(3);
+        accessResourceThatNotExist.setSharing(true);
+        Resource resourceInvented = new Resource("InventedResource");
+        ElasticityModel elasModel = new ElasticityModel("InventedResource" + "elasModel");
+        elasModel.setElasticityCost(50);
+        elasModel.setElasticity(2);
+        resourceInvented.setElasticityModel(elasModel);
+        accessResourceThatNotExist.setResource(resourceInvented);
+        return accessResourceThatNotExist;
+    }
+    public System generateSystemAggregator() {
+        System outputSystem = new System("AggregatorUnitTests");
+        generateSystemResources();
+        outputSystem.addListTestCases(this.aggregatorTestClasses());
+        outputSystem.addResourceClass(this.getNewLightElasticResource());
+        outputSystem.addResourceClass(this.getNewMockElasticResource());
+        outputSystem.addResourceClass(this.getMediumElasticResource());
+        outputSystem.addResourceClass(this.getHeavyInelasticResource());
+        outputSystem.addResourceClass(this.getMediumInelasticResource());
+
+        return outputSystem;
+    }
+    public AccessMode getMediumInelasticAccessMode() {
+        AccessMode expectedAccessModeMedium = new AccessMode();
+        expectedAccessModeMedium.setSharing(false);
+        expectedAccessModeMedium.setConcurrency(1);
+        expectedAccessModeMedium.setResource(this.getMediumInelasticResource());
+        expectedAccessModeMedium.setType(new AccessModeTypes("READWRITE"));
+        return expectedAccessModeMedium;
+    }
+    public AccessMode getMediumElasticAccessMode() {
+        AccessMode expectedAccessModeMySQLMedium = new AccessMode();
+        expectedAccessModeMySQLMedium.setSharing(false);
+        expectedAccessModeMySQLMedium.setConcurrency(1);
+        expectedAccessModeMySQLMedium.setResource(this.getMediumElasticResource());
+        expectedAccessModeMySQLMedium.setType(new AccessModeTypes("READWRITE"));
+        return expectedAccessModeMySQLMedium;
+    }
+    public AccessMode getNewLightElasticAccessMode() {
+        AccessMode expectedAccessModeMySQLMedium = new AccessMode(this.getAccessModeLightElasticResource());
+        expectedAccessModeMySQLMedium.setResource(this.getNewLightElasticResource());
+        return expectedAccessModeMySQLMedium;
+    }
+    public AccessMode getNewMockElasticAccessMode() {
+        AccessMode expectedAccessModeMySQLMedium = new AccessMode(this.getMockElasticAccessMode());
+        expectedAccessModeMySQLMedium.setResource(this.getNewMockElasticResource());
+        return expectedAccessModeMySQLMedium;
+    }
+    public Resource getMediumInelasticResource() {
+        Resource expectedMediumInelasticResource = new Resource(this.getHeavyInelasticResource());
+        expectedMediumInelasticResource.addReplaceableResource(MEDIUM_INELASTIC_ID);
+        return expectedMediumInelasticResource;
+    }
+    public Resource getNewMockElasticResource() {
+        Resource mockElasticResource = new Resource(this.getMediumElasticResource());
+
+        mockElasticResource.addReplaceableResource(LIGHT_ELASTIC_ID);
+        mockElasticResource.addReplaceableResource(MOCK_ELASTIC_ID);
+        return mockElasticResource;
+    }
+    public Resource getNewLightElasticResource() {
+        Resource newLightElasticResource = new Resource(this.getMediumElasticResource());
+        newLightElasticResource.addReplaceableResource(LIGHT_ELASTIC_ID);
+
+        return newLightElasticResource;
+    }
+    public Resource getMediumElasticResource() {
+        Resource mediumElasticResource = new Resource(MEDIUM_ELASTIC_ID);
+
+        //Heavy Resource
+        mediumElasticResource.setElasticityModel(getElasticityModelMediumElasticResource(MEDIUM_ELASTIC_ID));
+        mediumElasticResource.setResourceType(Resource.type.LOGICAL);
+
+        return mediumElasticResource;
+    }
+    public ElasticityModel getElasticityModelMediumElasticResource(String name) {
+        ElasticityModel expectedElasticityModelMySQL = new ElasticityModel("elasModel" + name);
+        expectedElasticityModelMySQL.setElasticity(15);
+        expectedElasticityModelMySQL.setElasticityCost(55.0);
+        return expectedElasticityModelMySQL;
+    }
+    public List<TestCase> aggregatorTestClasses() {
+        List<TestCase> listTestCases = new LinkedList<>();
+        //T1 could be in Medium-Light-Mock-Elastic Resource with RO and in HeavyInelastic with RW
+        TestCase tCHOne = getTestCaseClass("tOneAgg", this.getNewMockElasticAccessMode(),
+                this.getAccessModeHeavyInElasticResource());
+
+        listTestCases.add(tCHOne);
+
+        //T2 could be in Medium-Light-Mock-Elastic Resource with NOACCESS and in HeavyInelastic with READONLY
+        TestCase tCHTwo = new TestCase("tTwoAgg", AggregatorClassTests.class);
+        AccessMode accessModifiedMock = this.getNewMockElasticAccessMode();
+        accessModifiedMock.setType(new AccessModeTypes("NOACCESS"));
+        tCHTwo.addAccessMode(accessModifiedMock);
+        AccessMode accessModifiedHeavyInElasticResource = this.getAccessModeHeavyInElasticResource();
+        accessModifiedHeavyInElasticResource.setType(new AccessModeTypes(("READONLY")));
+        tCHTwo.addAccessMode(accessModifiedHeavyInElasticResource);
+
+        listTestCases.add(tCHTwo);
+        //T3 could be in Medium-Light-Mock-Elastic Resource with READONLY and in Heavy-Medium-Inelastic with READWRITE
+        TestCase tCHThree = getTestCaseClass("tThreeAgg", this.getNewLightElasticAccessMode(),
+                this.getMediumInelasticAccessMode());
+
+        listTestCases.add(tCHThree);
+
+        //T4 could be in Medium-Light-Mock-Elastic Resource with READWRITE and in Heavy-Inelastic with READWRITE
+        TestCase tCHFour = getTestCaseClass("tFourAgg", this.getMediumElasticAccessMode(),
+                this.getAccessModeHeavyInElasticResource());
+
+        listTestCases.add(tCHFour);
+        //T5 could be in Light-Mock-Elastic Resource with READWRITE and in Heavy-Medium-Inelastic with READWRITE
+        TestCase tCHFive = getTestCaseClass("tFiveAgg", this.getNewLightElasticAccessMode(),
+                this.getMediumInelasticAccessMode());
+
+        listTestCases.add(tCHFive);
+        //T6 could be in Light-Mock-Elastic Resource with READWRITE and in Heavy-Inelastic with READWRITE
+        TestCase tCHSix = getTestCaseClass("tSixAgg", this.getNewLightElasticAccessMode(),
+                this.getAccessModeHeavyInElasticResource());
+
+        listTestCases.add(tCHSix);
+        //T7 could be in Light-Mock-Elastic Resource with READWRITE and in Heavy-Medium-Inelastic with READWRITE
+        TestCase tCHSeven = getTestCaseClass("tSevenAgg", this.getNewMockElasticAccessMode(),
+                this.getMediumInelasticAccessMode());
+
+        listTestCases.add(tCHSeven);
+        //ExpectedTGROUPS:
+        /*READONLY,NOACCESS,DYNAMIC  DS
+        heavyInElasRest  -> tTwoAgg
+        heavyInElasRest lightElasticResource  -> tTwoAgg
+        heavyInElasRest mockElasticResource  -> tTwoAgg
+          WRITE, READWRITE
+        * heavyInElasRest mediumElasticResource -> tFourAgg
+        * MedInElasRest lightElasticResource -> tFiveAgg tSevenAgg tThreeAgg
+        * heavyInElasRest  -> tFiveAgg tFourAgg tOneAgg tSevenAgg tSixAgg tThreeAgg
+        * MedInElasRest " -> tFiveAgg tSevenAgg tThreeAgg
+        * heavyInElasRest lightElasticResource  -> tFiveAgg tOneAgg tSevenAgg tSixAgg tThreeAgg
+        * heavyInElasRest mockElasticResource  -> tOneAgg tSevenAgg tThreeAgg
+        * MedInElasRest mockElasticResource  -> tSevenAgg tThreeAgg
+        * */
+
+        return listTestCases;
+    }
+    private TestCase getTestCaseClass(String name, AccessMode accessModeFirstResource,
+                                            AccessMode accessModeSecondResource) {
+        TestCase tCHSeven = new TestCase(name, AggregatorClassTests.class);
+        tCHSeven.addAccessMode(accessModeFirstResource);
+        tCHSeven.addAccessMode(accessModeSecondResource);
+        return tCHSeven;
+    }
+    public List<TGroup> getExpectedTGroups() throws IOException {
+        ResourceSerializer serializer = new ResourceSerializer();
+        Map<String, Resource> listAvailableResources = serializer.deserializeResources("AggregatorUnitTests");
+
+        List<TestCase> listTestCases = aggregatorTestClasses();
+
+        List<TGroup> tGroupList = new LinkedList<>();
+        TGroup tGroupOne = new TGroup();
+        tGroupOne.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupOne.addResource(listAvailableResources.get(LIGHT_ELASTIC_ID));
+        tGroupOne.addTestCase(listTestCases.get(1));
+
+        tGroupList.add(tGroupOne);
+
+        TGroup tGroupTwo = new TGroup();
+        tGroupTwo.addResource(listAvailableResources.get(MEDIUM_INELASTIC_ID));
+        tGroupTwo.addResource(listAvailableResources.get(MOCK_ELASTIC_ID));
+        tGroupTwo.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupTwo);
+
+        TGroup tGroupThree = new TGroup();
+        tGroupThree.addResource(listAvailableResources.get(MEDIUM_INELASTIC_ID));
+        tGroupThree.addResource(listAvailableResources.get(LIGHT_ELASTIC_ID));
+        tGroupThree.addTestCase(listTestCases.get(2));
+        tGroupThree.addTestCase(listTestCases.get(4));
+        tGroupThree.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupThree);
+
+        TGroup tGroupFour = new TGroup();
+        tGroupFour.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupFour.addResource(listAvailableResources.get(MOCK_ELASTIC_ID));
+        tGroupFour.addTestCase(listTestCases.get(0));
+        tGroupFour.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupFour);
+
+        TGroup tGroupFive = new TGroup();
+        tGroupFive.addResource(listAvailableResources.get(MEDIUM_INELASTIC_ID));
+        tGroupFive.addResource(listAvailableResources.get(MEDIUM_ELASTIC_ID));
+        tGroupFive.addTestCase(listTestCases.get(2));
+        tGroupFive.addTestCase(listTestCases.get(4));
+        tGroupFive.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupFive);
+
+        TGroup tGroupSix = new TGroup();
+        tGroupSix.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupSix.addResource(listAvailableResources.get(MOCK_ELASTIC_ID));
+        tGroupSix.addTestCase(listTestCases.get(1));
+        tGroupList.add(tGroupSix);
+
+        TGroup tGroupSeven = new TGroup();
+        tGroupSeven.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupSeven.addResource(listAvailableResources.get(MEDIUM_ELASTIC_ID));
+        tGroupSeven.addTestCase(listTestCases.get(0));
+        tGroupSeven.addTestCase(listTestCases.get(2));
+        tGroupSeven.addTestCase(listTestCases.get(3));
+        tGroupSeven.addTestCase(listTestCases.get(4));
+        tGroupSeven.addTestCase(listTestCases.get(5));
+        tGroupSeven.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupSeven);
+
+        TGroup tGroupEight = new TGroup();
+        tGroupEight.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupEight.addResource(listAvailableResources.get(MEDIUM_ELASTIC_ID));
+        tGroupEight.addTestCase(listTestCases.get(1));
+        tGroupList.add(tGroupEight);
+
+        TGroup tGroupNine = new TGroup();
+        tGroupNine.addResource(listAvailableResources.get(HEAVY_INELASTIC_ID));
+        tGroupNine.addResource(listAvailableResources.get(LIGHT_ELASTIC_ID));
+        tGroupNine.addTestCase(listTestCases.get(0));
+        tGroupNine.addTestCase(listTestCases.get(2));
+        tGroupNine.addTestCase(listTestCases.get(3));
+        tGroupNine.addTestCase(listTestCases.get(4));
+        tGroupNine.addTestCase(listTestCases.get(5));
+        tGroupNine.addTestCase(listTestCases.get(6));
+        tGroupList.add(tGroupNine);
+
+        return tGroupList.stream().sorted(Comparator.comparing(TGroup::toString)).collect(Collectors.toList());
+    }
+    public System getInvalidSystemAggregator() {
+
+        System outputSystem = new System("InvalidSystem");
+        generateSystemResources();
+        TestCase tcWithNoResource = new TestCase("TCNoRequired", AggregatorClassTests.class);
+        AccessMode accessResourceThatNotExist = getAccessModeClass();
+
+        tcWithNoResource.addAccessMode(accessResourceThatNotExist);
+
+        outputSystem.addListTestCases(this.aggregatorTestClasses());
+        //Resource that doesn't exist
+        outputSystem.addTestCase(tcWithNoResource);
+        //Repeated test case
+        outputSystem.addTestCase(getTestCaseClass("tSevenAgg", this.getNewMockElasticAccessMode(),
+                this.getMediumInelasticAccessMode()));
+
+        outputSystem.addResourceClass(this.getNewLightElasticResource());
+        outputSystem.addResourceClass(this.getNewMockElasticResource());
+        outputSystem.addResourceClass(this.getMediumElasticResource());
+        outputSystem.addResourceClass(this.getHeavyInelasticResource());
+        outputSystem.addResourceClass(this.getMediumInelasticResource());
+        //Repeated Resource
+        outputSystem.addResourceClass(this.getMediumInelasticResource());
+        return outputSystem;
+    }
+
+}