diff --git a/retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorTests.java b/retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorTests.java new file mode 100644 index 0000000..89e5186 --- /dev/null +++ b/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 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 tGroupsOutputAggregator = aggregator.generateTGroups(); + List expectedTGroups = utils.getExpectedTGroups(); + Assert.assertEquals(expectedTGroups, tGroupsOutputAggregator); + } + + @Test + public void testUnitArchAggInvalidTGroup() throws NotValidSystemException, IOException { + baseSystem = utils.getInvalidSystemAggregator(); + aggregator = new RetorchAggregator(baseSystem); + ArgumentCaptor argument = ArgumentCaptor.forClass(LoggingEvent.class); + verify(appender, atLeast(2)).doAppend(argument.capture()); + List listEvents = argument.getAllValues(); + List 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 argument = ArgumentCaptor.forClass(LoggingEvent.class); + verify(appender, atLeast(2)).doAppend(argument.capture()); + List listEvents = argument.getAllValues(); + List 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)); + } +} \ No newline at end of file diff --git a/retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorUtils.java b/retorch-orchestration/src/test/java/giis/retorch/orchestration/AggregatorUtils.java new file mode 100644 index 0000000..45df422 --- /dev/null +++ b/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 aggregatorTestClasses() { + List 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 getExpectedTGroups() throws IOException { + ResourceSerializer serializer = new ResourceSerializer(); + Map listAvailableResources = serializer.deserializeResources("AggregatorUnitTests"); + + List listTestCases = aggregatorTestClasses(); + + List 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; + } + +}