From 2623c8402a57e2035db69a9d92d2851050916801 Mon Sep 17 00:00:00 2001 From: shrikantawachar Date: Mon, 20 May 2019 12:11:54 +0530 Subject: Upgrade SDC from Titan to Janus Graph Upgrade SDC from Titan to Janus Graph Change-Id: I67fb8b8e60cc6751697bc5ff2f06754c92803786 Issue-ID: SDC-2296 Signed-off-by: shrikantawachar --- .../org/openecomp/sdc/be/model/ModelTestBase.java | 18 +- .../model/cache/ApplicationDataTypeCacheTest.java | 24 +- .../sdc/be/model/cache/ComponentCacheTest.java | 2 +- .../openecomp/sdc/be/model/cache/DaoInfoTest.java | 2 +- .../be/model/cache/jobs/CheckAndUpdateJobTest.java | 2 +- .../model/config/ModelOperationsSpringConfig.java | 3 +- .../jsonjanusgraph/datamodel/NodeTypeTest.java | 173 ++++++ .../datamodel/TopologyTemplateTest.java | 422 +++++++++++++ .../datamodel/ToscaElementTypeEnumTest.java | 25 + .../enums/JsonConstantKeysEnumTest.java | 22 + .../operations/ArchiveOperationTest.java | 495 +++++++++++++++ .../operations/ArtifactsOperationsTest.java | 83 +++ .../operations/CapabilitiesOperationTest.java | 87 +++ .../ExternalReferencesOperationTest.java | 227 +++++++ .../operations/GroupsOperationTest.java | 105 ++++ .../operations/InterfaceOperationTest.java | 497 +++++++++++++++ .../operations/NodeTemplateOperationGraphTest.java | 244 ++++++++ .../operations/NodeTemplateOperationTest.java | 366 +++++++++++ .../operations/PolicyOperationIntegrationTest.java | 133 ++++ .../operations/PolicyOperationTest.java | 94 +++ ...TemplateOperationCapabilityIntegrationTest.java | 197 ++++++ .../operations/TopologyTemplateOperationTest.java | 185 ++++++ .../ToscaElementOperationCatalogTest.java | 73 +++ .../operations/ToscaElementOperationTest.java | 363 +++++++++++ .../operations/ToscaElementOperationTestImpl.java | 74 +++ .../ToscaOperationFacadePoliciesTest.java | 134 ++++ .../operations/ToscaOperationFacadeTest.java | 692 +++++++++++++++++++++ .../operations/UpgradeOperationTest.java | 183 ++++++ .../jsonjanusgraph/utils/CapabilityTestUtils.java | 85 +++ .../model/jsonjanusgraph/utils/GraphTestUtils.java | 129 ++++ .../model/jsonjanusgraph/utils/IdMapperTest.java | 37 ++ .../jsonjanusgraph/utils/ModelConverterTest.java | 137 ++++ .../be/model/jsontitan/datamodel/NodeTypeTest.java | 173 ------ .../jsontitan/datamodel/TopologyTemplateTest.java | 423 ------------- .../datamodel/ToscaElementTypeEnumTest.java | 25 - .../jsontitan/enums/JsonConstantKeysEnumTest.java | 22 - .../jsontitan/operations/ArchiveOperationTest.java | 486 --------------- .../operations/ArtifactsOperationsTest.java | 83 --- .../operations/CapabilitiesOperationTest.java | 87 --- .../ExternalReferencesOperationTest.java | 226 ------- .../jsontitan/operations/GroupsOperationTest.java | 105 ---- .../operations/InterfaceOperationTest.java | 497 --------------- .../operations/NodeTemplateOperationGraphTest.java | 244 -------- .../operations/NodeTemplateOperationTest.java | 364 ----------- .../operations/PolicyOperationIntegrationTest.java | 134 ---- .../jsontitan/operations/PolicyOperationTest.java | 93 --- ...TemplateOperationCapabilityIntegrationTest.java | 198 ------ .../operations/TopologyTemplateOperationTest.java | 177 ------ .../ToscaElementOperationCatalogTest.java | 73 --- .../operations/ToscaElementOperationTest.java | 363 ----------- .../operations/ToscaElementOperationTestImpl.java | 74 --- .../ToscaOperationFacadePoliciesTest.java | 135 ---- .../operations/ToscaOperationFacadeTest.java | 688 -------------------- .../jsontitan/operations/UpgradeOperationTest.java | 183 ------ .../model/jsontitan/utils/CapabilityTestUtils.java | 85 --- .../be/model/jsontitan/utils/GraphTestUtils.java | 129 ---- .../sdc/be/model/jsontitan/utils/IdMapperTest.java | 37 -- .../model/jsontitan/utils/ModelConverterTest.java | 137 ---- .../impl/AdditionalInformationOperationTest.java | 56 +- .../impl/AnnotationTypeOperationsTest.java | 10 +- .../operations/impl/ArtifactOperationTest.java | 75 ++- .../impl/CapabilityTypeOperationTest.java | 39 +- .../impl/ComponentInstanceOperationTest.java | 22 +- .../operations/impl/ElementOperationTest.java | 14 +- .../operations/impl/GroupTypeOperationTest.java | 78 ++- .../impl/HeatParametersOperationTest.java | 38 +- .../impl/InterfaceLifecycleOperationTest.java | 39 +- .../operations/impl/PolicyTypeOperationTest.java | 32 +- .../operations/impl/PropertyOperationTest.java | 74 +-- .../impl/RelationshipTypeOperationTest.java | 51 +- .../impl/ToscaElementLifecycleOperationTest.java | 71 ++- .../operations/impl/UserAdminOperationTest.java | 86 +-- .../operations/impl/util/OperationTestsUtil.java | 30 +- .../be/model/operations/impl/util/PrintGraph.java | 40 +- 74 files changed, 5674 insertions(+), 5635 deletions(-) create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeTypeTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplateTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnumTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnumTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperationsTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationGraphTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationIntegrationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationCapabilityIntegrationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationCatalogTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTestImpl.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadePoliciesTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperationTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityTestUtils.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/GraphTestUtils.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapperTest.java create mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityTestUtils.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapperTest.java delete mode 100644 catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverterTest.java (limited to 'catalog-model/src/test/java') diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java index 9efdc95bce..046161ab40 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java @@ -20,14 +20,14 @@ package org.openecomp.sdc.be.model; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.openecomp.sdc.be.config.Configuration; import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; @@ -54,7 +54,7 @@ public class ModelTestBase { Configuration configuration = new Configuration(); - configuration.setTitanInMemoryGraph(true); + configuration.setJanusGraphInMemoryGraph(true); Map deploymentRIArtifacts = new HashMap<>(); ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition(); @@ -66,13 +66,13 @@ public class ModelTestBase { configurationManager.getConfiguration().setDeploymentResourceInstanceArtifacts(deploymentRIArtifacts); } - protected void removeGraphVertices(Either graphResult) { - TitanGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + protected void removeGraphVertices(Either graphResult) { + JanusGraph graph = graphResult.left().value(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCacheTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCacheTest.java index 48681867f9..82c8ae603d 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCacheTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCacheTest.java @@ -9,7 +9,7 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; import org.openecomp.sdc.be.resources.data.DataTypeData; @@ -54,7 +54,7 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testGetAllDataTypesFromGraph() throws Exception { - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test result = Deencapsulation.invoke(testSubject, "getAllDataTypesFromGraph"); @@ -62,7 +62,7 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testGetAll() throws Exception { - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test result = testSubject.getAll(); @@ -71,7 +71,7 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testGet() throws Exception { String uniqueId = ""; - Either result; + Either result; // default test result = testSubject.get(uniqueId); @@ -80,13 +80,13 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testGet2() throws Exception { String uniqueId = ""; - Either result; + Either result; HashMap a = new HashMap<>(); DataTypeDefinition value1 = new DataTypeDefinition(); value1.setUniqueId("mock"); a.put("mock", value1); - Either, TitanOperationStatus> value = Either.left(a); + Either, JanusGraphOperationStatus> value = Either.left(a); Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value); // default test Deencapsulation.invoke(testSubject, "replaceAllData"); @@ -100,7 +100,8 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testRun2() throws Exception { - Either, TitanOperationStatus> value = Either.right(TitanOperationStatus.GENERAL_ERROR); + Either, JanusGraphOperationStatus> value = Either.right( + JanusGraphOperationStatus.GENERAL_ERROR); Mockito.when(propertyOperation.getAllDataTypeNodes()).thenReturn(value); testSubject.run(); } @@ -109,14 +110,14 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ public void testRun3() throws Exception { LinkedList a = new LinkedList<>(); a.add(new DataTypeData()); - Either, TitanOperationStatus> value = Either.left(a); + Either, JanusGraphOperationStatus> value = Either.left(a); Mockito.when(propertyOperation.getAllDataTypeNodes()).thenReturn(value); HashMap a1 = new HashMap<>(); DataTypeDefinition value1 = new DataTypeDefinition(); value1.setUniqueId("mock"); a1.put("mock", value1); - Either, TitanOperationStatus> value2 = Either.left(a1); + Either, JanusGraphOperationStatus> value2 = Either.left(a1); Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value2); Deencapsulation.invoke(testSubject, "replaceAllData"); @@ -152,7 +153,7 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ DataTypeDefinition value1 = new DataTypeDefinition(); value1.setUniqueId("mock"); a.put("mock", value1); - Either, TitanOperationStatus> value = Either.left(a); + Either, JanusGraphOperationStatus> value = Either.left(a); Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value); // default test Deencapsulation.invoke(testSubject, "replaceAllData"); @@ -160,7 +161,8 @@ public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{ @Test public void testReplaceAllData2() throws Exception { - Either, TitanOperationStatus> value = Either.right(TitanOperationStatus.GENERAL_ERROR); + Either, JanusGraphOperationStatus> value = Either.right( + JanusGraphOperationStatus.GENERAL_ERROR); Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value); // default test Deencapsulation.invoke(testSubject, "replaceAllData"); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ComponentCacheTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ComponentCacheTest.java index 49e847acf6..62155e2be5 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ComponentCacheTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ComponentCacheTest.java @@ -22,7 +22,7 @@ import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.Product; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.resources.data.ComponentCacheData; import org.openecomp.sdc.be.unittests.utils.ModelConfDependentTest; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/DaoInfoTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/DaoInfoTest.java index 2e2f36b9c7..8c4d9d5378 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/DaoInfoTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/DaoInfoTest.java @@ -1,7 +1,7 @@ package org.openecomp.sdc.be.model.cache; import org.junit.Test; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; public class DaoInfoTest { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/jobs/CheckAndUpdateJobTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/jobs/CheckAndUpdateJobTest.java index 5347bc0d76..4e54ba7a29 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/jobs/CheckAndUpdateJobTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/jobs/CheckAndUpdateJobTest.java @@ -14,7 +14,7 @@ import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.cache.ComponentCache; import org.openecomp.sdc.be.model.cache.DaoInfo; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.resources.data.ComponentMetadataData; import org.openecomp.sdc.be.resources.data.ResourceMetadataData; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java index d6b2dd61e7..7e0a72e474 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java @@ -6,7 +6,8 @@ import org.springframework.context.annotation.PropertySource; @Configuration @ComponentScan({"org.openecomp.sdc.be.dao.cassandra", "org.openecomp.sdc.be.model.cache", - "org.openecomp.sdc.be.model.jsontitan.operations", "org.openecomp.sdc.be.model.jsontitan.utils", + "org.openecomp.sdc.be.model.jsonjanusgraph.operations", + "org.openecomp.sdc.be.model.jsonjanusgraph.utils", "org.openecomp.sdc.be.model.operations.impl"}) @PropertySource("classpath:dao.properties") public class ModelOperationsSpringConfig { } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeTypeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeTypeTest.java new file mode 100644 index 0000000000..e4e377ff78 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/NodeTypeTest.java @@ -0,0 +1,173 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import java.util.List; +import java.util.Map; + +import org.junit.Test; +import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; + + +public class NodeTypeTest { + + private NodeType createTestSubject() { + return new NodeType(); + } + + + @Test + public void testGetDerivedList() throws Exception { + NodeType testSubject; + List result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDerivedList(); + } + + + @Test + public void testSetDerivedList() throws Exception { + NodeType testSubject; + List derivedList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDerivedList(derivedList); + } + + + @Test + public void testGetDerivedFrom() throws Exception { + NodeType testSubject; + List result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDerivedFrom(); + } + + + @Test + public void testSetDerivedFrom() throws Exception { + NodeType testSubject; + List derivedFrom = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDerivedFrom(derivedFrom); + } + + + @Test + public void testGetAttributes() throws Exception { + NodeType testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAttributes(); + } + + + @Test + public void testSetAttributes() throws Exception { + NodeType testSubject; + Map attributes = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAttributes(attributes); + } + + + @Test + public void testGetCapabilties() throws Exception { + NodeType testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCapabilities(); + } + + + @Test + public void testSetCapabilties() throws Exception { + NodeType testSubject; + Map capabilties = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCapabilities(capabilties); + } + + + @Test + public void testGetRequirements() throws Exception { + NodeType testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRequirements(); + } + + + @Test + public void testSetRequirements() throws Exception { + NodeType testSubject; + Map requirements = null; + + // default test + testSubject = createTestSubject(); + testSubject.setRequirements(requirements); + } + + + @Test + public void testGetCapabiltiesProperties() throws Exception { + NodeType testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCapabilitiesProperties(); + } + + + @Test + public void testSetCapabiltiesProperties() throws Exception { + NodeType testSubject; + Map capabiltiesProperties = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCapabilitiesProperties(capabiltiesProperties); + } + + + @Test + public void testGetInterfaceArtifacts() throws Exception { + NodeType testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInterfaceArtifacts(); + } + + + @Test + public void testSetInterfaceArtifacts() throws Exception { + NodeType testSubject; + Map interfaceArtifacts = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInterfaceArtifacts(interfaceArtifacts); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplateTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplateTest.java new file mode 100644 index 0000000000..4875ca69f7 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/TopologyTemplateTest.java @@ -0,0 +1,422 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import java.util.Map; + +import org.junit.Test; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; + + +public class TopologyTemplateTest { + + private TopologyTemplate createTestSubject() { + return new TopologyTemplate(); + } + + + @Test + public void testGetInputs() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInputs(); + } + + + @Test + public void testSetInputs() throws Exception { + TopologyTemplate testSubject; + Map inputs = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInputs(inputs); + } + + + @Test + public void testGetInstInputs() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstInputs(); + } + + + @Test + public void testSetInstInputs() throws Exception { + TopologyTemplate testSubject; + Map instInputs = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstInputs(instInputs); + } + + + @Test + public void testGetHeatParameters() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getHeatParameters(); + } + + + @Test + public void testSetHeatParameters() throws Exception { + TopologyTemplate testSubject; + Map heatParameters = null; + + // default test + testSubject = createTestSubject(); + testSubject.setHeatParameters(heatParameters); + } + + + @Test + public void testGetInstAttributes() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstAttributes(); + } + + + @Test + public void testSetInstAttributes() throws Exception { + TopologyTemplate testSubject; + Map instAttributes = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstAttributes(instAttributes); + } + + + @Test + public void testGetInstProperties() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstProperties(); + } + + + @Test + public void testSetInstProperties() throws Exception { + TopologyTemplate testSubject; + Map instProperties = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstProperties(instProperties); + } + + + @Test + public void testGetGroups() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGroups(); + } + + + @Test + public void testSetGroups() throws Exception { + TopologyTemplate testSubject; + Map groups = null; + + // default test + testSubject = createTestSubject(); + testSubject.setGroups(groups); + } + + + @Test + public void testGetInstGroups() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstGroups(); + } + + + @Test + public void testSetInstGroups() throws Exception { + TopologyTemplate testSubject; + Map instGroups = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstGroups(instGroups); + } + + + @Test + public void testGetServiceApiArtifacts() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getServiceApiArtifacts(); + } + + + @Test + public void testSetServiceApiArtifacts() throws Exception { + TopologyTemplate testSubject; + Map serviceApiArtifacts = null; + + // default test + testSubject = createTestSubject(); + testSubject.setServiceApiArtifacts(serviceApiArtifacts); + } + + + @Test + public void testGetCompositions() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCompositions(); + } + + + @Test + public void testSetCompositions() throws Exception { + TopologyTemplate testSubject; + Map compositions = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCompositions(compositions); + } + + + @Test + public void testGetCalculatedCapabilities() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCalculatedCapabilities(); + } + + + @Test + public void testSetCalculatedCapabilities() throws Exception { + TopologyTemplate testSubject; + Map calculatedCapabilities = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCalculatedCapabilities(calculatedCapabilities); + } + + + @Test + public void testGetCalculatedRequirements() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCalculatedRequirements(); + } + + + @Test + public void testSetCalculatedRequirements() throws Exception { + TopologyTemplate testSubject; + Map calculatedRequirements = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCalculatedRequirements(calculatedRequirements); + } + + + @Test + public void testGetFullfilledCapabilities() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFullfilledCapabilities(); + } + + + @Test + public void testSetFullfilledCapabilities() throws Exception { + TopologyTemplate testSubject; + Map fullfilledCapabilities = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFullfilledCapabilities(fullfilledCapabilities); + } + + + @Test + public void testGetFullfilledRequirements() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFullfilledRequirements(); + } + + + @Test + public void testSetFullfilledRequirements() throws Exception { + TopologyTemplate testSubject; + Map fullfilledRequirements = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFullfilledRequirements(fullfilledRequirements); + } + + + @Test + public void testGetInstDeploymentArtifacts() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstDeploymentArtifacts(); + } + + + @Test + public void testSetInstDeploymentArtifacts() throws Exception { + TopologyTemplate testSubject; + Map instDeploymentArtifacts = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstDeploymentArtifacts(instDeploymentArtifacts); + } + + + @Test + public void testGetCalculatedCapabilitiesProperties() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCalculatedCapabilitiesProperties(); + } + + + @Test + public void testSetCalculatedCapabilitiesProperties() throws Exception { + TopologyTemplate testSubject; + Map calculatedCapabilitiesProperties = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCalculatedCapabilitiesProperties(calculatedCapabilitiesProperties); + } + + + @Test + public void testGetInstanceArtifacts() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getInstanceArtifacts(); + } + + + @Test + public void testSetInstanceArtifacts() throws Exception { + TopologyTemplate testSubject; + Map instanceArtifacts = null; + + // default test + testSubject = createTestSubject(); + testSubject.setInstanceArtifacts(instanceArtifacts); + } + + + @Test + public void testGetDataTypes() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDataTypes(); + } + + + @Test + public void testSetDataTypes() throws Exception { + TopologyTemplate testSubject; + Map dataTypes = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDataTypes(dataTypes); + } + + + @Test + public void testGetComponentInstances() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getComponentInstances(); + } + + + @Test + public void testSetComponentInstances() throws Exception { + TopologyTemplate testSubject; + Map instances = null; + + // default test + testSubject = createTestSubject(); + testSubject.setComponentInstances(instances); + } + + + @Test + public void testGetRelations() throws Exception { + TopologyTemplate testSubject; + Map result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRelations(); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnumTest.java new file mode 100644 index 0000000000..f175aa3d51 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/datamodel/ToscaElementTypeEnumTest.java @@ -0,0 +1,25 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.datamodel; + +import org.junit.Test; + + +public class ToscaElementTypeEnumTest { + + private ToscaElementTypeEnum createTestSubject() { + return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE; + } + + + + + + @Test + public void testGetValue() throws Exception { + ToscaElementTypeEnum testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getValue(); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnumTest.java new file mode 100644 index 0000000000..a37a157428 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/enums/JsonConstantKeysEnumTest.java @@ -0,0 +1,22 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.enums; + +import org.junit.Test; + + +public class JsonConstantKeysEnumTest { + + private JsonConstantKeysEnum createTestSubject() { + return JsonConstantKeysEnum.COMPOSITION; + } + + + @Test + public void testGetValue() throws Exception { + JsonConstantKeysEnum testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getValue(); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperationTest.java new file mode 100644 index 0000000000..ce208d9b3a --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArchiveOperationTest.java @@ -0,0 +1,495 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Created by yavivi on 21/03/2018. + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(value = {"classpath:application-context-test.xml", "classpath:healing-context-test.xml"}) +public class ArchiveOperationTest extends ModelTestBase { + + private static final String CI_UID_RES1_CP = "cp_uid"; + private static final String CI_UID_RES2_VL = "vl_uid"; + private static final String CI_UID_SVC_PROXY = "svc_proxy_uid"; + + @Resource + private ArchiveOperation archiveOperation; + + @Resource + private JanusGraphDao janusGraphDao; + + private boolean isInitialized; + + private GraphVertex serviceVertex1; + private GraphVertex archivedVertex1; + + GraphVertex archiveVertex; + GraphVertex catalogVertex; + + private GraphVertex serviceVertex1_0; + private GraphVertex serviceVertex1_1; + private GraphVertex serviceVertex2_0; + private GraphVertex serviceVertex3_0; + private GraphVertex serviceVertex3_1; + + private GraphVertex serviceVertex0_1; + private GraphVertex serviceVertex0_2; + private GraphVertex serviceVertex0_3; + private GraphVertex serviceVertex0_4; + private GraphVertex serviceVertex0_5; + + //Composition Elements + private GraphVertex compositionService; + private GraphVertex compositionResource1; + private GraphVertex compositionResource2; + private GraphVertex compositionServiceProxy; + private GraphVertex compositionAnotherService; + + //For VSP Archive Notification + private GraphVertex vfResource0_1; + private GraphVertex vfResource0_2; + private GraphVertex vfResource1_0; + private String csarUuid = "123456789";; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(janusGraphDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testArchiveComponentSingleVersion(){ + String componentId = serviceVertex1.getUniqueId(); + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); + assertThat(actionStatus.isLeft()).isTrue(); + assertArchived(serviceVertex1.getUniqueId()); + } + + @Test + public void testArchiveComponentFailsWhenInCheckoutSingleVersion(){ + checkoutComponent(serviceVertex1); + String componentId = serviceVertex1.getUniqueId(); + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); + assertThat(actionStatus.isLeft()).isFalse(); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); + } + + @Test + public void testArchiveWithWrongId() { + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent("fakeComponentId"); + assertThat(actionStatus.isLeft()).isFalse(); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); + } + + @Test + public void testAlreadyArchived() { + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(archivedVertex1.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactly(archivedVertex1.getUniqueId()); + } + + @Test + public void testScenario2_archive_1_0(){ + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_0.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); + assertArchived(serviceVertex1_0.getUniqueId()); + assertArchived(serviceVertex1_1.getUniqueId()); + } + + @Test + public void testScenario2_archive_1_1(){ + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_1.getUniqueId()); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); + assertArchived(serviceVertex1_0.getUniqueId()); + assertArchived(serviceVertex1_1.getUniqueId()); + } + + @Test + public void testScenario4_oneLowOneHighestVersion(){ + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); + assertArchived(serviceVertex0_1.getUniqueId()); + assertArchived(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_3.getUniqueId()); + assertArchived(serviceVertex0_4.getUniqueId()); + assertArchived(serviceVertex0_5.getUniqueId()); + + actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); + } + + + /////////////// Continue Here ////////////////// + @Test + public void testScenario4_archiveFromNonHighest(){ + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_1.getUniqueId()); + assertArchived(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_3.getUniqueId()); + assertArchived(serviceVertex0_4.getUniqueId()); + assertArchived(serviceVertex0_5.getUniqueId()); + + actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_3.getUniqueId()); + assertRestored(serviceVertex0_1.getUniqueId()); + assertRestored(serviceVertex0_2.getUniqueId()); + assertRestored(serviceVertex0_3.getUniqueId()); + assertRestored(serviceVertex0_4.getUniqueId()); + assertRestored(serviceVertex0_5.getUniqueId()); + } + + @Test + public void testArchiveFailsWhenHighestVersionIsInCheckoutState(){ + checkoutComponent(serviceVertex0_5); + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); + } + + @Test + public void testScenario3_archive_3_0(){ + Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex3_0.getUniqueId()); + assertArchived(serviceVertex3_0.getUniqueId()); + assertArchived(serviceVertex3_1.getUniqueId()); + assertArchivedProps(serviceVertex2_0.getUniqueId()); + } + + @Test + public void testArchivedOriginsCalculation(){ + + //Archive the CP resource + this.archiveOperation.archiveComponent(this.compositionResource1.getUniqueId()); + this.archiveOperation.archiveComponent(this.compositionServiceProxy.getUniqueId()); + + List ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); + + //Validate that method returns the CI of CP + assertThat(ciWithArchivedOrigins).containsExactlyInAnyOrder(CI_UID_RES1_CP, CI_UID_SVC_PROXY); + + Map compositionsJson = (Map) this.compositionService.getJson(); + + assertThat(compositionsJson).isNotNull(); + assertThat(compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue())).isNotNull(); + + CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + + //Get all component instances from composition + Map componentInstances = composition.getComponentInstances(); + for (ComponentInstanceDataDefinition ci : componentInstances.values()) { + //Verify that exactly 2 CIs are marked as archived + if (ci.getUniqueId().equals(CI_UID_RES1_CP) || ci.getUniqueId().equals(CI_UID_SVC_PROXY)) { + assertThat(ci.isOriginArchived()).isTrue(); + } + } + + } + + @Test + public void testNoArchivedOriginsCalculation(){ + List ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); + + //Validate that method returns the CI of CP + assertThat(ciWithArchivedOrigins).isEmpty(); + } + + @Test + public void testOnVspArchivedAndRestored(){ + this.archiveOperation.onVspArchived(csarUuid); + //assertOnCommit(); + + assertOnVspArchived(true); + + this.archiveOperation.onVspRestored(csarUuid); + //assertOnCommit(); + assertOnVspArchived(false); + + //Not Found CSAR UUID + ActionStatus result = this.archiveOperation.onVspRestored("fakeUuid"); + //assertOnCommit(); + assertThat(result).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); + } + + private void assertOnVspArchived(boolean expectedValue) { + GraphVertex v = janusGraphDao.getVertexById(vfResource0_1.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + + v = janusGraphDao.getVertexById(vfResource0_2.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + + v = janusGraphDao.getVertexById(vfResource1_0.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + } + + /************************** + * Utility Methods + *************************/ + + private void checkoutComponent(GraphVertex serviceVertex0_5) { + Either vE = janusGraphDao.getVertexById(serviceVertex0_5.getUniqueId()); + GraphVertex v = vE.left().value(); + v.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + v.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + janusGraphDao.updateVertex(v); + assertOnCommit(); + } + + private void assertOnCommit(){ + final JanusGraphOperationStatus commit = this.janusGraphDao.commit(); + assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK); + } + + private void assertArchived(String componentUniqueId) { + assertArchivedOrRestored(ArchiveOperation.Action.ARCHIVE, componentUniqueId); + } + + private void assertRestored(String componentUniqueId) { + assertArchivedOrRestored(ArchiveOperation.Action.RESTORE, componentUniqueId); + } + + private void assertArchivedOrRestored(ArchiveOperation.Action action, String componentUniqueId) { + GraphVertex v = janusGraphDao.getVertexById(componentUniqueId).left().value(); + + EdgeLabelEnum requiredEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.ARCHIVE_ELEMENT : EdgeLabelEnum.CATALOG_ELEMENT; + EdgeLabelEnum otherEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.CATALOG_ELEMENT : EdgeLabelEnum.ARCHIVE_ELEMENT; + + GraphVertex parent = null; + Either otherLookup = null; + Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + if (isHighest != null && isHighest) { + //Highest version are linked to Archive/Catalog Root + parent = janusGraphDao.getParentVertex(v, requiredEdge, JsonParseFlagEnum.NoParse).left().value(); + otherLookup = janusGraphDao.getParentVertex(v, otherEdge, JsonParseFlagEnum.NoParse); + assertThat(otherLookup.isRight()).isTrue(); //Verify that component is not linked to Catalog/Archive Root + assertThat(parent.getUniqueId()).isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? this.archiveVertex.getUniqueId() : this.catalogVertex.getUniqueId()); //Verify that parent is indeed Archive Root + } + + assertArchivedOrRestoredProps(action, v); + } + + private void assertArchivedProps(String uniqueId) { + GraphVertex v = + janusGraphDao.getVertexById(uniqueId).left().value(); + assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v); + } + + private void assertRestoredProps(String uniqueId) { + GraphVertex v = + janusGraphDao.getVertexById(uniqueId).left().value(); + assertArchivedOrRestoredProps(ArchiveOperation.Action.RESTORE, v); + } + + private void assertArchivedOrRestoredProps(ArchiveOperation.Action action, GraphVertex v) { + Object isArchived = v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); + Object archiveTime = v.getMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME); + assertThat(isArchived).isNotNull().isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? true : false); + assertThat(archiveTime).isNotNull(); + } + + /******************************* + * Preperation Methods + *******************************/ + private void initGraphForTest() { + //Create Catalog Root + this.catalogVertex = GraphTestUtils.createRootCatalogVertex(janusGraphDao); + //Create Archive Root + this.archiveVertex = GraphTestUtils.createRootArchiveVertex(janusGraphDao); + + createScenario1_SingleVersionNode(); + createScenario2_TwoHighestVersions(); + createScenario3_TwoHighestVersionsOneLowest(); + createMiscServices(); + createServiceCompositionForCalculatingArchivedOrigins(); + createScenario4_1Highest4LowestVersions(); + createResourcesForArchivedVsp(); + + assertOnCommit(); + } + + private void createScenario1_SingleVersionNode() { + //Create Service for Scenario 1 Tests (1 Service) + this.serviceVertex1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + + //Connect Service to Catalog Root + janusGraphDao.createEdge(catalogVertex, serviceVertex1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario2_TwoHighestVersions() { + //Create Service for Scenario 2 Tests (1 Service) + this.serviceVertex1_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + + janusGraphDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null); + + //Connect 1.0 and 1.1 to Catalog Root + janusGraphDao + .createEdge(catalogVertex, serviceVertex1_0, EdgeLabelEnum.CATALOG_ELEMENT, null); + janusGraphDao + .createEdge(catalogVertex, serviceVertex1_1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario3_TwoHighestVersionsOneLowest() { + //Create Service for Scenario 1 Tests (1 Service) + this.serviceVertex2_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); //NonHighestVersion + this.serviceVertex3_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + this.serviceVertex3_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + + //Connect version edges + janusGraphDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null); + janusGraphDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null); + + //Connect 3.0 and 3.1 to Catalog Root + janusGraphDao + .createEdge(catalogVertex, serviceVertex3_0, EdgeLabelEnum.CATALOG_ELEMENT, null); + janusGraphDao + .createEdge(catalogVertex, serviceVertex3_1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario4_1Highest4LowestVersions() { + //2 Lowest version only + this.serviceVertex0_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); + this.serviceVertex0_2 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); + this.serviceVertex0_3 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); + this.serviceVertex0_4 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); + this.serviceVertex0_5 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + + janusGraphDao.createEdge(serviceVertex0_1, serviceVertex0_2, EdgeLabelEnum.VERSION, null); + janusGraphDao.createEdge(serviceVertex0_2, serviceVertex0_3, EdgeLabelEnum.VERSION, null); + janusGraphDao.createEdge(serviceVertex0_3, serviceVertex0_4, EdgeLabelEnum.VERSION, null); + janusGraphDao.createEdge(serviceVertex0_4, serviceVertex0_5, EdgeLabelEnum.VERSION, null); + + janusGraphDao + .createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createResourcesForArchivedVsp(){ + Map vfPropsNonHighest = propsForNonHighestVersion(); + Map vfPropsHighest = propsForNonHighestVersion(); + + vfPropsNonHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); + vfPropsNonHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); + vfPropsHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); + vfPropsHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); + + this.vfResource0_1 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsNonHighest, ResourceTypeEnum.VF); + this.vfResource0_2 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsNonHighest, ResourceTypeEnum.VF); + this.vfResource1_0 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsHighest, ResourceTypeEnum.VF); + + janusGraphDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null); + janusGraphDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null); + } + + private void createMiscServices() { + //Create Service for Scenario 1 Tests (1 Service) + this.archivedVertex1 = GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>()); + + //Connect Service to Catalog Root + janusGraphDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null); + } + + private void createServiceCompositionForCalculatingArchivedOrigins(){ + //Service that point to another service in composition + this.compositionService = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + this.compositionAnotherService = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion()); + + this.compositionResource1 = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.CP); + this.compositionResource2 = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.VL); + this.compositionServiceProxy = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.ServiceProxy); + + janusGraphDao + .createEdge(compositionService, compositionResource1, EdgeLabelEnum.INSTANCE_OF, null); + janusGraphDao + .createEdge(compositionService, compositionResource2, EdgeLabelEnum.INSTANCE_OF, null); + janusGraphDao + .createEdge(compositionService, compositionServiceProxy, EdgeLabelEnum.INSTANCE_OF, null); + janusGraphDao + .createEdge(compositionService, compositionAnotherService, EdgeLabelEnum.PROXY_OF, null); + + createAndAttachCompositionJson(compositionService); + } + + private void createAndAttachCompositionJson(GraphVertex compositionService) { + //Full composition json + Map compositions = new HashMap<>(); + //Single composition data + CompositionDataDefinition composition = new CompositionDataDefinition(); + //Instances Map + Map instances = new HashMap<>(); + + //Prepare Instances Map + ComponentInstanceDataDefinition instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_RES1_CP); + instance.setComponentUid(compositionResource1.getUniqueId()); + instances.put(CI_UID_RES1_CP, instance); + + instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_RES2_VL); + instance.setComponentUid(compositionResource2.getUniqueId()); + instances.put(CI_UID_RES2_VL, instance); + + instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_SVC_PROXY); + instance.setComponentUid(compositionServiceProxy.getUniqueId()); + instances.put(CI_UID_SVC_PROXY, instance); + + //Add Instances to Composition + composition.setComponentInstances(instances); + //Add to full composition + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition); + //Add Full Json to vertex + compositionService.setJson(compositions); + //System.out.println(JsonParserUtils.toJson(compositions)); + janusGraphDao.updateVertex(compositionService); + } + + private Map propsForHighestVersion(){ + Map props = new HashMap(); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + return props; + } + + private Map propsForNonHighestVersion(){ + Map props = new HashMap(); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + return props; + } + +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperationsTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperationsTest.java new file mode 100644 index 0000000000..160957d1f6 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperationsTest.java @@ -0,0 +1,83 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Test; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +public class ArtifactsOperationsTest { + + private static final String SERVICE_ID = "serviceId"; + private static final String INSTANCE_ID = "instanceId"; + private ArtifactsOperations testInstance = mock(ArtifactsOperations.class, CALLS_REAL_METHODS); + + @Test + public void getInstanceArtifacts_collectAllInstanceArtifacts() throws Exception { + Map instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); + + Map instanceDeploymentArtifacts = new HashMap<>(); + instanceDeploymentArtifacts.put(INSTANCE_ID, getArtifactsByInstance("name2", "name3")); + instanceDeploymentArtifacts.put("instanceId2", getArtifactsByInstance("name4")); + + doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.left(instanceDeploymentArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + + assertTrue(allInstArtifacts.isLeft()); + assertEquals(allInstArtifacts.left().value().size(), 3); + assertTrue(allInstArtifacts.left().value().containsKey("name1")); + assertTrue(allInstArtifacts.left().value().containsKey("name2")); + assertTrue(allInstArtifacts.left().value().containsKey("name3")); + assertFalse(allInstArtifacts.left().value().containsKey("name4"));//this key is of different instance + } + + @Test + public void getInstanceArtifacts_noArtifactsForInstance() throws Exception { + Map instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); + + doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, "someOtherInstance"); + + assertTrue(allInstArtifacts.isLeft()); + assertTrue(allInstArtifacts.left().value().isEmpty()); + } + + @Test + public void getInstanceArtifacts_errorGettingInstanceArtifacts() throws Exception { + doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + verify(testInstance, times(0)).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + assertTrue(allInstArtifacts.isRight()); + } + + @Test + public void getAllInstanceArtifacts_errorGettingDeploymentArtifacts() throws Exception { + doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + assertTrue(allInstArtifacts.isRight()); + } + + private ToscaDataDefinition getArtifactsByInstance(String ... artifactsNames) { + MapArtifactDataDefinition artifactsByInstance = new MapArtifactDataDefinition(); + Map artifactsByName = new HashMap<>(); + for (String artifactName : artifactsNames) { + artifactsByName.put(artifactName, new ArtifactDataDefinition()); + } + artifactsByInstance.setMapToscaDataDefinition(artifactsByName); + return artifactsByInstance; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperationTest.java new file mode 100644 index 0000000000..5fc2ef2cae --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/CapabilitiesOperationTest.java @@ -0,0 +1,87 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.CapabilityTestUtils; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +import java.util.HashMap; +import java.util.Map; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +public class CapabilitiesOperationTest { + + @InjectMocks + CapabilitiesOperation operation = new CapabilitiesOperation(); + @Mock + private JanusGraphDao mockJanusGraphDao; + @Mock + private TopologyTemplateOperation topologyTemplateOperation; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK); + when(mockJanusGraphDao.getVertexById(anyString(), any())).thenReturn(Either.left(new GraphVertex())); + + when(topologyTemplateOperation.updateFullToscaData(any(), any(), any(), anyMap())).thenReturn(StorageOperationStatus.OK); + TopologyTemplate topologyTemplate = new TopologyTemplate(); + + Map capPropsForTopologyTemplate = CapabilityTestUtils + .createCapPropsForTopologyTemplate(topologyTemplate); + topologyTemplate.setCapabilitiesProperties(capPropsForTopologyTemplate); + + when(topologyTemplateOperation.getToscaElement(anyString(), any())).thenReturn(Either.left(topologyTemplate)); + } + + @Test + public void testCreateOrUpdateCapabilitiesProperties() { + + Map mapToscaDataDefinition = new HashMap<>(); + PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(); + propertyDataDefinition.setUniqueId("ComponentInput1_uniqueId"); + propertyDataDefinition.setName("propName"); + mapToscaDataDefinition.put(propertyDataDefinition.getUniqueId(), propertyDataDefinition); + MapPropertiesDataDefinition mapPropertiesDataDefinition = new MapPropertiesDataDefinition(mapToscaDataDefinition); + + Map propertiesMap = new HashMap<>(); + propertiesMap.put(propertyDataDefinition.getUniqueId(), mapPropertiesDataDefinition); + + StorageOperationStatus operationStatus = operation.createOrUpdateCapabilityProperties("componentId", + propertiesMap); + + Assert.assertEquals(StorageOperationStatus.OK, operationStatus); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperationTest.java new file mode 100644 index 0000000000..8900377bb2 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ExternalReferencesOperationTest.java @@ -0,0 +1,227 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.IdMapper; +import org.openecomp.sdc.be.model.operations.StorageException; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; + +/** + * Created by yavivi on 26/01/2018. + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class ExternalReferencesOperationTest extends ModelTestBase { + + private static final String COMPONENT_ID = "ci-MyComponentName"; + private static final String COMPONENT2_ID = "ci-MyComponentName2"; + private static final String MONITORING_OBJECT_TYPE = "monitoring"; + private static final String WORKFLOW_OBJECT_TYPE = "workflow"; + private static final String REF_1 = "ref1"; + private static final String REF_2 = "ref2"; + private static final String REF_3 = "ref3"; + private static final String REF_4 = "ref4"; + private static final String REF_5 = "ref5"; + //workflow + private static final String REF_6 = "ref6"; + + @Resource + private ExternalReferencesOperation externalReferenceOperation; + + @Resource + private JanusGraphDao janusGraphDao; + + private boolean isInitialized; + + private GraphVertex serviceVertex; + private GraphVertex serviceVertex2; + private GraphVertex serviceVertex3; + + private String serviceVertexUuid; + private String serviceVertex2Uuid; + private String serviceVertex3Uuid; + + private IdMapper idMapper; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + idMapper = Mockito.mock(IdMapper.class); + this.externalReferenceOperation.setIdMapper(idMapper); + when(idMapper.mapComponentNameToUniqueId(Mockito.anyString(), Mockito.any(GraphVertex.class))).thenReturn(COMPONENT_ID); + if (!isInitialized) { + GraphTestUtils.clearGraph(janusGraphDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testAddComponentInstanceExternalRef(){ + Either addResult = externalReferenceOperation.addExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_4); + assertThat(addResult.isLeft()).isEqualTo(true); + + //commit changes to janusgraph + final JanusGraphOperationStatus commit = this.janusGraphDao.commit(); + assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK); + + assertThat(getServiceExternalRefs()).contains(REF_1, REF_2, REF_3, REF_4); + } + + @Test + public void testAddExternalReferences_success() { + Map> refsMap = Collections.singletonMap(MONITORING_OBJECT_TYPE, Arrays.asList(REF_1, REF_2)); + externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID, refsMap); + Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isEqualTo(1); + assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); + externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID, refsMap); + Map> allExternalReferences2 = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID); + assertThat(allExternalReferences2.size()).isEqualTo(1); + assertThat(allExternalReferences2).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); + } + + @Test + public void testGetAllCIExternalRefs_success() { + Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertexUuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isEqualTo(2); + assertThat(allExternalReferences).flatExtracting(WORKFLOW_OBJECT_TYPE).containsExactly(REF_6); + assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2, REF_3, REF_5); + } + + @Test + public void testGetAllCIExternalRefs_noRefsExist() { + Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isZero(); + } + + @Test + public void testGetAllCIExternalRefs_noSuchComponentInstance() { + Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, "FAKE"); + assertThat(allExternalReferences.size()).isZero(); + } + + @Test(expected=StorageException.class) + public void testGetAllCIExternalRefs_nonExitingService_throwsException() { + externalReferenceOperation.getAllExternalReferences("FAKE", COMPONENT_ID); + } + + @Test + public void testGetComponentInstanceExternalRef(){ + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE).left().value()).containsExactly(REF_6); + } + + @Test + public void testGetComponentInstanceExternalRefForNonExistingObjectId(){ + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); + Either, ActionStatus> getResult = externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, "FAKE_OBJECT_TYPE"); + assertThat(getResult.left().value()).isEmpty(); + } + + @Test + public void testDeleteComponentInstanceExternalRef(){ + //Test the precondition + assertThat(getServiceExternalRefs()).contains(REF_5); + + //Remove REF 5 + Either deleteStatus = externalReferenceOperation.deleteExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); + assertThat(deleteStatus.isLeft()).isEqualTo(true); + + //commit changes to janusgraph + final JanusGraphOperationStatus commit = this.janusGraphDao.commit(); + assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK); + + //Check that ref does not exist anymore + assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3); + } + + @Test + public void testUpdateComponentInstanceExternalRef(){ + //Test the precondition + assertThat(getServiceExternalRefs()).contains(REF_5).doesNotContain(REF_4); + + //Update REF 5 with REF_4 + Either updateResult = externalReferenceOperation.updateExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5, REF_4); + + assertThat(updateResult.isLeft()).isEqualTo(true); + + //commit changes to janusgraph + final JanusGraphOperationStatus commit = this.janusGraphDao.commit(); + assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK); + + //Check that ref does not exist anymore + assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3, REF_4); + } + + private List getServiceExternalRefs(){ + //Get service vertex + final Either externalRefsVertexResult = this.janusGraphDao + .getChildVertex(this.serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, JsonParseFlagEnum.ParseJson); + assertThat(externalRefsVertexResult.isLeft()).isEqualTo(true); + + GraphVertex externalRefVertex = externalRefsVertexResult.left().value(); + + //Get the full map + Map componentInstancesMap = (Map) externalRefVertex.getJson(); + assertThat(componentInstancesMap).isNotNull(); + + //Get Map of external refs by object type + final MapComponentInstanceExternalRefs mapComponentInstanceExternalRefs = componentInstancesMap.get(COMPONENT_ID); + + //Get List of references + //final List externalRefsByObjectType = mapComponentInstanceExternalRefs.externalRefsByObjectType(objectType); + + return mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE); + } + + private void initGraphForTest() { + //create a service + this.serviceVertex = GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>()); + this.serviceVertexUuid = this.serviceVertex.getUniqueId(); + + //monitoring references + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_1); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_2); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_3); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); + + //workflow references + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE, REF_6); + + //create a service without refs + serviceVertex2 = GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>()); + serviceVertex2Uuid = serviceVertex2.getUniqueId(); + + //create a service for adding all references + serviceVertex3 = GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>()); + serviceVertex3Uuid = serviceVertex3.getUniqueId(); + + final JanusGraphOperationStatus commit = this.janusGraphDao.commit(); + assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperationTest.java new file mode 100644 index 0000000000..e93ec3c616 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/GroupsOperationTest.java @@ -0,0 +1,105 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import static java.util.Arrays.asList; +import static org.assertj.core.api.Assertions.assertThat; + +import fj.data.Either; +import java.util.List; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class}) +public class GroupsOperationTest extends ModelTestBase { + + @Autowired + private GroupsOperation groupsOperation; + + @Autowired + HealingJanusGraphDao janusGraphDao; + + @Autowired + private ToscaOperationFacade toscaOperationFacade; + private Component container; + + @BeforeClass + public static void initClass() { + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + container = new Resource(); + container.setUniqueId(CONTAINER_ID); + Either createdCmpt = janusGraphDao.createVertex(createBasicContainerGraphVertex()); + assertThat(createdCmpt.isLeft()).isTrue(); + + } + + @After + public void tearDown() throws Exception { + janusGraphDao.rollback(); + } + + @Test + public void addGroups_whenContainerHasNoGroups_associateContainerWithGroup() { + GroupDefinition g1 = createGroupDefinition("g1"); + GroupDefinition g2 = createGroupDefinition("g2"); + Either, StorageOperationStatus> createGroups = groupsOperation.addGroups(container, asList(g1, g2)); + assertThat(createGroups.isLeft()).isTrue(); + + ComponentParametersView getGroupsFilter = new ComponentParametersView(true); + getGroupsFilter.setIgnoreGroups(false); + Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); + assertThat(cmptWithGroups.getGroups()) + .usingElementComparatorOnFields("name", "uniqueId") + .containsExactlyInAnyOrder(g1, g2); + } + + @Test + public void addGroups_whenContainerHasGroups_addTheGivenGroupsToTheGroupsList() { + GroupDefinition g1 = createGroupDefinition("g1"); + GroupDefinition g2 = createGroupDefinition("g2"); + groupsOperation.addGroups(container, asList(g1, g2)).left().value(); + + GroupDefinition g3 = createGroupDefinition("g3"); + GroupDefinition g4 = createGroupDefinition("g4"); + + groupsOperation.addGroups(container, asList(g3, g4)).left().value(); + + ComponentParametersView getGroupsFilter = new ComponentParametersView(true); + getGroupsFilter.setIgnoreGroups(false); + Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); + assertThat(cmptWithGroups.getGroups()) + .usingElementComparatorOnFields("name", "uniqueId") + .containsExactlyInAnyOrder(g1, g2, g3, g4); + + } + + private GroupDefinition createGroupDefinition(String id) { + GroupDefinition groupDefinition = new GroupDefinition(); + groupDefinition.setUniqueId(id); + groupDefinition.setName("name" + id); + return groupDefinition; + } + + +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperationTest.java new file mode 100644 index 0000000000..31d3f86967 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/InterfaceOperationTest.java @@ -0,0 +1,497 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + +import fj.data.Either; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.annotation.Resource; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.InterfaceDefinition; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.Operation; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.category.SubCategoryDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class InterfaceOperationTest extends ModelTestBase { + + private static final String RESOURCE_NAME = "Resource Name"; + private static final String RESOURCE_ID = "resourceID"; + private static final String SERVICE_NAME = "Service Name"; + private static final String SERVICE_ID = "serviceID"; + private final String categoryName = "category"; + private final String subcategory = "mycategory"; + private final Service service = createService(); + private final org.openecomp.sdc.be.model.Resource resource = createResource(); + @Resource + protected JanusGraphDao janusGraphDao; + @Resource + protected NodeTypeOperation nodeTypeOperation; + @Resource + protected TopologyTemplateOperation topologyTemplateOperation; + @Resource + private InterfaceOperation interfaceOperation; + @Resource + private ToscaElementLifecycleOperation lifecycleOperation; + private GraphVertex ownerVertex; + + @BeforeClass + public static void initInterfacesOperation() { + init(); + } + + @Before + public void setupBefore() { + GraphTestUtils.clearGraph(janusGraphDao); + createUsers(); + createResourceCategory(); + createServiceCategory(); + GraphTestUtils.createRootCatalogVertex(janusGraphDao); + createRootNodeType(); + createNodeType("resource", RESOURCE_ID); + createNodeType("service", SERVICE_ID); + createTopologyTemplate("firstService"); + } + + private void createUsers() { + GraphVertex ownerV = new GraphVertex(VertexTypeEnum.USER); + ownerV.setUniqueId("user1"); + + Map metadataProperties = new HashMap<>(); + metadataProperties.put(GraphPropertyEnum.USERID, ownerV.getUniqueId()); + metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); + metadataProperties.put(GraphPropertyEnum.NAME, "user1"); + ownerV.setMetadataProperties(metadataProperties); + ownerV.updateMetadataJsonWithCurrentMetadataProperties(); + ownerV.setJson(new HashMap<>()); + Either createUserRes = janusGraphDao.createVertex(ownerV); + + ownerVertex = createUserRes.left().value(); + + GraphVertex modifierV = new GraphVertex(VertexTypeEnum.USER); + modifierV.setUniqueId("user2"); + + metadataProperties = new HashMap<>(); + metadataProperties.put(GraphPropertyEnum.USERID, modifierV.getUniqueId()); + metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); + metadataProperties.put(GraphPropertyEnum.NAME, "user2"); + modifierV.setMetadataProperties(metadataProperties); + modifierV.updateMetadataJsonWithCurrentMetadataProperties(); + modifierV.setJson(new HashMap<>()); + createUserRes = janusGraphDao.createVertex(modifierV); + createUserRes.left().value(); + + lifecycleOperation.findUser(ownerVertex.getUniqueId()); + } + + private void createResourceCategory() { + GraphVertex cat = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY); + Map metadataProperties = new HashMap<>(); + String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.RESOURCE_CATEGORY); + cat.setUniqueId(catId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); + metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_CATEGORY.getName()); + metadataProperties.put(GraphPropertyEnum.NAME, categoryName); + metadataProperties + .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); + cat.setMetadataProperties(metadataProperties); + cat.updateMetadataJsonWithCurrentMetadataProperties(); + + GraphVertex subCat = new GraphVertex(VertexTypeEnum.RESOURCE_SUBCATEGORY); + metadataProperties = new HashMap<>(); + String subCatId = UniqueIdBuilder.buildSubCategoryUid(cat.getUniqueId(), subcategory); + subCat.setUniqueId(subCatId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, subCatId); + metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_SUBCATEGORY.getName()); + metadataProperties.put(GraphPropertyEnum.NAME, subcategory); + metadataProperties + .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(subcategory)); + subCat.setMetadataProperties(metadataProperties); + subCat.updateMetadataJsonWithCurrentMetadataProperties(); + + Either catRes = janusGraphDao.createVertex(cat); + Either subCatRes = janusGraphDao.createVertex(subCat); + janusGraphDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), + EdgeLabelEnum.SUB_CATEGORY, new HashMap<>()); + } + + private void createServiceCategory() { + GraphVertex cat = new GraphVertex(VertexTypeEnum.SERVICE_CATEGORY); + Map metadataProperties = new HashMap<>(); + String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.SERVICE_CATEGORY); + cat.setUniqueId(catId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); + metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.SERVICE_CATEGORY.getName()); + metadataProperties.put(GraphPropertyEnum.NAME, categoryName); + metadataProperties + .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); + cat.setMetadataProperties(metadataProperties); + cat.updateMetadataJsonWithCurrentMetadataProperties(); + janusGraphDao.createVertex(cat); + } + + private void createRootNodeType() { + NodeType vf = new NodeType(); + String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); + vf.setUniqueId(uniqueId); + vf.setComponentType(ComponentTypeEnum.RESOURCE); + vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); + vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), "root"); + vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); + vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "1.0"); + vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VFC.name()); + vf.getMetadata() + .put(JsonPresentationFields.LIFECYCLE_STATE.getPresentation(), LifecycleStateEnum.CERTIFIED.name()); + vf.getMetadata().put(JsonPresentationFields.TOSCA_RESOURCE_NAME.getPresentation(), "root"); + vf.getMetadata().put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true); + + List categories = new ArrayList<>(); + CategoryDefinition cat = new CategoryDefinition(); + categories.add(cat); + cat.setName(categoryName); + List subCategories = new ArrayList<>(); + SubCategoryDefinition subCat = new SubCategoryDefinition(); + subCat.setName(subcategory); + subCategories.add(subCat); + cat.setSubcategories(subCategories); + vf.setCategories(categories); + + List derivedFrom = new ArrayList<>(); + vf.setDerivedFrom(derivedFrom); + + Map properties = new HashMap<>(); + PropertyDataDefinition prop1 = new PropertyDataDefinition(); + prop1.setName("derived1"); + prop1.setDefaultValue("deriveddef1"); + properties.put("derived1", prop1); + + PropertyDataDefinition prop2 = new PropertyDataDefinition(); + prop2.setUniqueId("derived2"); + prop2.setName("deriveddef2"); + properties.put("derived2", prop2); + + PropertyDataDefinition prop3 = new PropertyDataDefinition(); + prop3.setName("derived3"); + prop3.setDefaultValue("deriveddef3"); + properties.put("derived3", prop3); + + vf.setProperties(properties); + vf.setComponentType(ComponentTypeEnum.RESOURCE); + Either createVFRes = nodeTypeOperation.createNodeType(vf); + + Either getNodeTyeRes = + janusGraphDao.getVertexById(createVFRes.left().value().getUniqueId()); + getNodeTyeRes.left().value(); + } + + private void createNodeType(String nodeTypeName, String uniqueId) { + NodeType vf = new NodeType(); + vf.setUniqueId(uniqueId); + vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); + vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), nodeTypeName); + vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); + vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); + vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); + vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); + List categories = new ArrayList<>(); + CategoryDefinition cat = new CategoryDefinition(); + categories.add(cat); + cat.setName(categoryName); + List subCategories = new ArrayList<>(); + SubCategoryDefinition subCat = new SubCategoryDefinition(); + subCat.setName(subcategory); + subCategories.add(subCat); + cat.setSubcategories(subCategories); + vf.setCategories(categories); + + List derivedFrom = new ArrayList<>(); + derivedFrom.add("root"); + vf.setDerivedFrom(derivedFrom); + + vf.setComponentType(ComponentTypeEnum.RESOURCE); + + List addProperties = new ArrayList<>(); + PropertyDataDefinition prop11 = new PropertyDataDefinition(); + prop11.setName("prop11"); + prop11.setDefaultValue("def11"); + + addProperties.add(prop11); + + PropertyDataDefinition prop22 = new PropertyDataDefinition(); + prop22.setName("prop22"); + prop22.setDefaultValue("def22"); + addProperties.add(prop22); + + Either createVFRes = nodeTypeOperation.createNodeType(vf); + Either getNodeTyeRes = + janusGraphDao.getVertexById(createVFRes.left().value().getUniqueId()); + GraphVertex vfVertex = getNodeTyeRes.left().value(); + StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, + VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME); + assertSame(StorageOperationStatus.OK, status); + + PropertyDataDefinition prop33 = new PropertyDataDefinition(); + prop33.setName("prop33"); + prop33.setDefaultValue("def33"); + + status = nodeTypeOperation + .addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, + prop33, JsonPresentationFields.NAME); + assertSame(StorageOperationStatus.OK, status); + + PropertyDataDefinition prop44 = new PropertyDataDefinition(); + prop44.setName("prop44"); + prop44.setDefaultValue("def44"); + + status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, + VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME); + assertSame(StorageOperationStatus.OK, status); + + PropertyDataDefinition capProp = new PropertyDataDefinition(); + capProp.setName("capProp"); + capProp.setDefaultValue("capPropDef"); + + MapDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + dataToCreate.put("capProp", capProp); + + Map capProps = new HashMap<>(); + capProps.put("capName", dataToCreate); + + nodeTypeOperation.associateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, + EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); + + List pathKeys = new ArrayList<>(); + pathKeys.add("capName"); + capProp.setDefaultValue("BBBB"); + nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, + VertexTypeEnum.CAPABILITIES_PROPERTIES, capProp, pathKeys, JsonPresentationFields.NAME); + } + + private void createTopologyTemplate(String name) { + TopologyTemplate service = new TopologyTemplate(); + String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); + service.setUniqueId(uniqueId); + service.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); + service.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), name); + service.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); + service.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); + service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); + service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); + List categories = new ArrayList<>(); + CategoryDefinition cat = new CategoryDefinition(); + categories.add(cat); + cat.setName(categoryName); + service.setCategories(categories); + + service.setComponentType(ComponentTypeEnum.SERVICE); + Either createRes = + topologyTemplateOperation.createTopologyTemplate(service); + Either getNodeTyeRes = + janusGraphDao.getVertexById(createRes.left().value().getUniqueId()); + + getNodeTyeRes.left().value(); + } + + @After + public void cleanAfter() { + GraphTestUtils.clearGraph(janusGraphDao); + } + + @Test + public void testAddInterface_Service() { + testAddSingleInterface(service); + } + + private void testAddSingleInterface(Component component) { + InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); + Either, StorageOperationStatus> res = interfaceOperation + .addInterfaces(component.getUniqueId(), + Collections.singletonList( + interfaceDefinition)); + Assert.assertTrue(res.isLeft()); + Assert.assertEquals("1", res.left().value().get(0).getUniqueId()); + } + + private InterfaceDefinition buildInterfaceDefinition(String uniqueId) { + InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.standard"); + interfaceDefinition.setUniqueId(uniqueId); + interfaceDefinition.setOperationsMap(createMockOperationMap()); + return interfaceDefinition; + } + + private Map createMockOperationMap() { + Map operationMap = new HashMap<>(); + operationMap.put("op1", createMockOperation()); + return operationMap; + } + + private Operation createMockOperation() { + Operation operation = new Operation(); + operation.setDefinition(false); + operation.setName("create"); + operation.setUniqueId("op1"); + return operation; + } + + @Test + public void testAddInterface_Resource() { + testAddMultipleInterface(resource); + } + + private void testAddMultipleInterface(Component component) { + InterfaceDefinition interfaceDefinition1 = buildInterfaceDefinition("1"); + InterfaceDefinition interfaceDefinition2 = buildInterfaceDefinition("2"); + List interfaceDefinitions = new ArrayList<>(); + interfaceDefinitions.add(interfaceDefinition1); + interfaceDefinitions.add(interfaceDefinition2); + Either, StorageOperationStatus> res = + interfaceOperation.addInterfaces(component.getUniqueId(), interfaceDefinitions); + Assert.assertTrue(res.isLeft()); + Assert.assertEquals(2, res.left().value().size()); + } + + @Test + public void testUpdateInterface_Service() { + testUpdateInterface(service); + } + + private void testUpdateInterface(Component component) { + InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); + Either, StorageOperationStatus> res = interfaceOperation + .addInterfaces(component.getUniqueId(), + Collections.singletonList( + interfaceDefinition)); + Assert.assertTrue(res.isLeft()); + List value = res.left().value(); + InterfaceDefinition createdInterfaceDef = value.get(0); + String newDescription = "New Description"; + createdInterfaceDef.setDescription(newDescription); + res = interfaceOperation + .updateInterfaces(component.getUniqueId(), Collections.singletonList(createdInterfaceDef)); + assertTrue(res.isLeft()); + assertEquals(newDescription, res.left().value().get(0).getDescription()); + } + + @Test + public void testUpdateInterface_Resource() { + testUpdateInterface(resource); + } + + @Test + public void testDeleteInterface_Service() { + testDeleteInterface(service); + } + + private void testDeleteInterface(Component component) { + InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); + Either, StorageOperationStatus> res = interfaceOperation + .addInterfaces(component.getUniqueId(), + Collections.singletonList( + interfaceDefinition)); + Assert.assertTrue(res.isLeft()); + List value = res.left().value(); + Either deleteInterfaceOperationRes = + interfaceOperation.deleteInterface(component.getUniqueId(), value.get(0).getUniqueId()); + assertTrue(deleteInterfaceOperationRes.isLeft()); + } + + @Test + public void testDeleteInterface_Resource() { + testDeleteInterface(resource); + } + + @Test + public void testUpdateInterfaceShouldFailWhenNOtCreatedFirst() { + Component component = createResource(); + InterfaceDefinition interfaceDefinition = buildInterfaceDefinitionWithoutOperation(); + interfaceDefinition.setOperationsMap(createMockOperationMap()); + Either, StorageOperationStatus> res = interfaceOperation.updateInterfaces( + component.getUniqueId(), Collections.singletonList(interfaceDefinition)); + Assert.assertTrue(res.isRight()); + } + + private InterfaceDefinition buildInterfaceDefinitionWithoutOperation() { + InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.standard"); + return interfaceDefinition; + } + + private org.openecomp.sdc.be.model.Resource createResource() { + org.openecomp.sdc.be.model.Resource resource = new org.openecomp.sdc.be.model.Resource(); + resource.setUniqueId(RESOURCE_ID); + resource.setName(RESOURCE_NAME); + resource.setDescription("My short description"); + resource.setInterfaces(createMockInterfaceDefinition()); + return resource; + } + + private Service createService() { + Service service = new Service(); + service.setUniqueId(SERVICE_ID); + service.setName(SERVICE_NAME); + service.setDescription("My short description"); + service.setInterfaces(createMockInterfaceDefinition()); + return service; + } + + private Map createMockInterfaceDefinition() { + Map operationMap = createMockOperationMap(); + Map interfaceDefinitionMap = new HashMap<>(); + interfaceDefinitionMap.put("int1", createInterface("int1", "Interface 1", "lifecycle", "tosca", operationMap)); + return interfaceDefinitionMap; + } + + private InterfaceDefinition createInterface(String uniqueId, String description, String type, + String toscaResourceName, Map op) { + InterfaceDefinition id = new InterfaceDefinition(); + id.setType(type); + id.setDescription(description); + id.setUniqueId(uniqueId); + id.setToscaResourceName(toscaResourceName); + id.setOperationsMap(op); + return id; + } + + @After + public void teardown() { + GraphTestUtils.clearGraph(janusGraphDao); + } + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationGraphTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationGraphTest.java new file mode 100644 index 0000000000..0131783bea --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationGraphTest.java @@ -0,0 +1,244 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import javax.annotation.Resource; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.io.IoCore; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class}) +public class NodeTemplateOperationGraphTest extends ModelTestBase{ + @Resource + private HealingJanusGraphDao janusGraphDao; + @Resource + private NodeTemplateOperation nodeTemplateOperation; + + private JanusGraph graphT; + private GraphVertex containerVertex; + private String containeId; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + @Before + public void before(){ + + Either graph = janusGraphDao.getGraph(); + graphT = graph.left().value(); + + containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + containeId = "containerId"; + containerVertex.setUniqueId(containeId); + Either createVertex = janusGraphDao.createVertex(containerVertex); + assertTrue(createVertex.isLeft()); + } + + @After + public void after(){ + janusGraphDao.rollback(); + + } + + + String outputDirectory = "C:\\Output"; + + @Test + public void testCreateInstanceEdge(){ + + Map> mapOriginToInstId = new HashMap<>(); + createIntancesFromSameResource(mapOriginToInstId, 1, 3); + createIntancesFromSameResource(mapOriginToInstId, 2, 4); + createIntancesFromSameResource(mapOriginToInstId, 3, 1); + +// exportGraphMl(graphT); + + validateOnGraph(mapOriginToInstId, 3); + } + + @Test + public void testRemoveInstanceEdge(){ + //create 3 instances from same resource orig1 + Map> mapOriginToInstId = new HashMap<>(); + String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3); + validateOnGraph(mapOriginToInstId, 1); + + //remove instance 2 + String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1); + mapOriginToInstId.get(originId).remove(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + //create new instance from orig1 + instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null); + mapOriginToInstId.get(originId).add(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + //create 1 instance from same resource orig2 + originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1); + validateOnGraph(mapOriginToInstId, 2); + + //remove instance of orig 2 + instanceId = removeInstanceEdge(containerVertex, originId, 2, 1); + mapOriginToInstId.get(originId).remove(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + } + + @Test + public void testProxyInstanceEdge(){ + Map> mapOriginToInstId = new HashMap<>(); + String proxyId = createOrigin(2); + createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId); + + validateOnGraph(mapOriginToInstId, 1); + } + private void validateOnGraph(Map> mapOriginToInstId, int expectedEdgeCount) { + validateOnGraph(mapOriginToInstId, expectedEdgeCount, false); + } + private void validateOnGraph(Map> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) { + Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices(); + assertNotNull(vertices); + Iterator iterator = vertices.iterator(); + assertTrue(iterator.hasNext()); + Vertex containerV = iterator.next(); + validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF); + if ( validateProxy ){ + validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF); + } + } + private void validatePerEdgeType(Map> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) { + Iterator edges = containerV.edges(Direction.OUT, edgeLabel.name()); + assertNotNull(edges); + + int counter = 0; + while (edges.hasNext()){ + Edge edge = edges.next(); + counter++; + validateEdge(edge, mapOriginToInstId); + } + assertEquals("check edge size", expectedEdgeCount, counter); + } + + + private String createIntancesFromSameResource(Map> mapOriginToInstId, int originIndex, int countInstances) { + return createIntancesFromSameResource(mapOriginToInstId, originIndex, countInstances, false, null); + } + + private String createIntancesFromSameResource(Map> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) { + + List exp = new ArrayList(); + String originId = createOrigin(originIndex); + + for ( int i = 0; i < countInstances; i++){ + String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId); + exp.add(instanceId); + } + mapOriginToInstId.put(originId, exp); + if ( isProxy ){ + mapOriginToInstId.put(proxyId, exp); + } + return originId; + } + + private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) { + ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); + componentInstance.setComponentUid(originId); + String instanceId = buildInstanceId(originIndex, insIndex); + componentInstance.setUniqueId(instanceId); + componentInstance.setIsProxy(isProxy); + componentInstance.setSourceModelUid(proxyId); + StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance); + assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus); + return instanceId; + } + + private String buildInstanceId(int originIndex, int insIndex) { + StringBuffer sb = new StringBuffer("instanceId_"); + sb.append(originIndex).append("-").append(insIndex); + return sb.toString(); + } + private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) { + ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); + componentInstance.setComponentUid(originId); + String instanceId = buildInstanceId(originIndex, insIndex); + componentInstance.setUniqueId(instanceId); + StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance); + assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus); + return instanceId; + } + + + private String createOrigin(int index) { + Either createVertex; + GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE); + String originId = "originId_" + index; + originVertex.setUniqueId(originId); + createVertex = janusGraphDao.createVertex(originVertex); + assertTrue(createVertex.isLeft()); + return originId; + } + private void validateEdge(Edge edge, Map> mapOriginToInstId) { + List expextedInList; + + Vertex originV = edge.inVertex(); + String id = (String) janusGraphDao.getProperty((JanusGraphVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty()); + expextedInList = mapOriginToInstId.get(id); + + List list = (List) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES); + assertThat(list).hasSameSizeAs(expextedInList); + assertThat(list).containsOnlyElementsOf(expextedInList); + } + + private String exportGraphMl(JanusGraph graph) { + String result = null; + String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml"; + try { + try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) { + graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph); + } + result = outputFile; + } catch (Exception e) { + e.printStackTrace(); + } + return result; + + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java new file mode 100644 index 0000000000..1455d1e984 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java @@ -0,0 +1,366 @@ +/* + + * Copyright (c) 2018 AT&T Intellectual Property. + + * + + * Licensed under the Apache License, Version 2.0 (the "License"); + + * you may not use this file except in compliance with the License. + + * You may obtain a copy of the License at + + * + + * http://www.apache.org/licenses/LICENSE-2.0 + + * + + * Unless required by applicable law or agreed to in writing, software + + * distributed under the License is distributed on an "AS IS" BASIS, + + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + + * See the License for the specific language governing permissions and + + * limitations under the License. + + */ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import com.google.common.collect.Lists; +import fj.data.Either; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class NodeTemplateOperationTest extends ModelTestBase { + + private final static String COMPONENT_ID = "componentId"; + private final static String TO_INSTANCE_ID = "toInstanceId"; + private final static String FROM_INSTANCE_ID = "fromInstanceId"; + private final static String RELATION_ID = "relationId"; + private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId"; + private final static String CAPABILITY_UID = "capabilityUid"; + private final static String CAPABILITY_NAME = "capabilityName"; + private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId"; + private final static String REQUIREMENT_UID = "requirementUid"; + private final static String REQUIREMENT_NAME = "requirementName"; + private final static String RELATIONSHIP_TYPE = "relationshipType"; + + private static Map fulfilledCapability; + private static Map fulfilledRequirement; + private static CapabilityDataDefinition capability; + private static RequirementDataDefinition requirement; + private static RequirementCapabilityRelDef relation; + + @InjectMocks + private static NodeTemplateOperation operation; + + @Mock + private static JanusGraphDao janusGraphDao; + + @Mock + private static TopologyTemplateOperation topologyTemplateOperation; + + @BeforeClass + public static void setup() { + init(); + janusGraphDao = Mockito.mock(JanusGraphDao.class); + operation = new NodeTemplateOperation(); + operation.setJanusGraphDao(janusGraphDao); + buildDataDefinition(); + } + + private static void buildDataDefinition() { + buildCapabiltyDataDefinition(); + buildRequirementDataDefinition(); + buildRelation(); + } + + @Test + public void testGetFulfilledCapabilityByRelationSuccess(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either vertexRes = Either.left(vertex); + when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + GraphVertex dataVertex = new GraphVertex(); + dataVertex.setJson(fulfilledCapability); + Either childVertexRes = Either.left(dataVertex); + when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); + assertTrue(result.isLeft()); + assertEquals(result.left().value(), capability); + } + + @Test + public void testGetFulfilledRequirementByRelationSuccess(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either vertexRes = Either.left(vertex); + when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + GraphVertex dataVertex = new GraphVertex(); + dataVertex.setJson(fulfilledRequirement); + Either childVertexRes = Either.left(dataVertex); + when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); + assertTrue(result.isLeft()); + assertEquals(result.left().value(), requirement); + } + + @Test + public void testGetFulfilledCapabilityByRelationNotFoundFailure(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either vertexRes = Either.left(vertex); + when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + Either childVertexRes = Either.right( + JanusGraphOperationStatus.NOT_FOUND); + when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); + assertTrue(result.isRight()); + assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); + } + + @Test + public void testGetFulfilledRequirementByRelationNotFoundFailure(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either vertexRes = Either.left(vertex); + when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + Either childVertexRes = Either.right( + JanusGraphOperationStatus.NOT_FOUND); + when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); + assertTrue(result.isRight()); + assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); + } + + @Test + public void testUpdateCIMetadataOfTopologyTemplate() { + Either, StorageOperationStatus> result; + String id = "id"; + TopologyTemplate container = new TopologyTemplate(); + ToscaElement toscaElement = new TopologyTemplate(); + toscaElement.setResourceType(ResourceTypeEnum.VF); + ComponentInstance componentInstance = new ComponentInstance(); + componentInstance.setName(id); + componentInstance.setComponentUid(id); + container.setUniqueId(id); + GraphVertex graphVertex = new GraphVertex(); + when(janusGraphDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex)); + when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex)); + when(topologyTemplateOperation.getToscaElement(anyString())).thenReturn(Either.left(toscaElement)); + + result = operation.updateComponentInstanceMetadataOfTopologyTemplate(container, toscaElement, componentInstance); + assertTrue(result.isLeft()); + } + + @Test + public void testGetDefaultHeatTimeout() { + Integer result; + + // default test + result = NodeTemplateOperation.getDefaultHeatTimeout(); + } + + @Test + public void testPrepareInstDeploymentArtifactPerInstance() { + Map deploymentResourceArtifacts = new HashMap<>(); + Map deploymentArtifacts = new HashMap<>(); + ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition(); + artifactDataDefinition.setArtifactType("HEAT"); + artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT); + deploymentArtifacts.put("1", artifactDataDefinition); + deploymentResourceArtifacts.put("1", artifactDataDefinition); + String componentInstanceId = "componentInstanceId"; + User user = new User(); + user.setUserId("userId"); + user.setFirstName("first"); + user.setLastName("last"); + String envType = "VfHeatEnv"; + MapArtifactDataDefinition result; + + result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user, + envType); + Assert.assertEquals(2, result.getMapToscaDataDefinition().size()); + } + + @Test + public void testCreateCapPropertyKey() throws Exception { + String key = ""; + String instanceId = ""; + String result; + + // default test + result = NodeTemplateOperation.createCapPropertyKey(key, instanceId); + } + + @Test + public void testPrepareCalculatedCapabiltyForNodeType() { + Map capabilities = new HashMap<>(); + ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition(); + List listToscaDataDefinition = new ArrayList<>(); + CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition(); + capabilityDataDefinition.setMaxOccurrences("1"); + listToscaDataDefinition.add(capabilityDataDefinition); + listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition); + capabilities.put("1", listCapDataDefinition); + ComponentInstance componentInstance = createCompInstance(); + MapListCapabilityDataDefinition result; + + result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance); + Assert.assertEquals(1, result.getMapToscaDataDefinition().size()); + } + + @Test + public void testPrepareCalculatedReqForNodeType() { + Map requirements = new HashMap<>(); + ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition(); + List listToscaDataDefinition = new ArrayList<>(); + RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition(); + reqDataDefinition.setMaxOccurrences("1"); + listToscaDataDefinition.add(reqDataDefinition); + listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition); + requirements.put("1", listReqDataDef); + ComponentInstance componentInstance = createCompInstance(); + MapListRequirementDataDefinition result; + + result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance); + Assert.assertEquals(1, result.getMapToscaDataDefinition().size()); + } + + @Test + public void testAddGroupInstancesToComponentInstance() throws Exception { + Component containerComponent = null; + ComponentInstanceDataDefinition componentInstance = null; + List groups = null; + Map> groupInstancesArtifacts = null; + StorageOperationStatus result; + + result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups, + groupInstancesArtifacts); + Assert.assertEquals(StorageOperationStatus.OK, result); + } + + @Test + public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception { + String componentId = ""; + String instanceId = ""; + List groupInstances = null; + StorageOperationStatus result; + + result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances); + Assert.assertEquals(StorageOperationStatus.OK, result); + } + + private ComponentInstance createCompInstance() { + ComponentInstance componentInstance = new ComponentInstance(); + String id = "id"; + componentInstance.setComponentUid(id); + componentInstance.setUniqueId(id); + componentInstance.setName(id); + return componentInstance; + } + private static void buildRequirementDataDefinition() { + buildRequirement(); + fulfilledRequirement = new HashMap<>(); + MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition(); + mapListRequirementDataDefinition.add(requirement.getCapability(), requirement); + fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition); + + } + + private static void buildRequirement() { + requirement = new RequirementDataDefinition(); + requirement.setOwnerId(REQUIREMENT_OWNER_ID); + requirement.setUniqueId(REQUIREMENT_UID); + requirement.setName(REQUIREMENT_NAME); + requirement.setRelationship(RELATIONSHIP_TYPE); + } + + private static void buildCapabiltyDataDefinition() { + buildCapability(); + fulfilledCapability = new HashMap<>(); + MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition(); + mapListCapabiltyDataDefinition.add(capability.getType(), capability); + fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition); + } + + private static void buildCapability() { + capability = new CapabilityDataDefinition(); + capability.setOwnerId(CAPABILITY_OWNER_ID); + capability.setUniqueId(CAPABILITY_UID); + capability.setName(CAPABILITY_NAME); + } + + private static void buildRelation() { + + relation = new RequirementCapabilityRelDef(); + CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + RelationshipInfo relationInfo = new RelationshipInfo(); + relationInfo.setId(RELATION_ID); + relationship.setRelation(relationInfo); + + relation.setRelationships(Lists.newArrayList(relationship)); + relation.setToNode(TO_INSTANCE_ID); + relation.setFromNode(FROM_INSTANCE_ID); + + relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID); + relationInfo.setCapabilityUid(CAPABILITY_UID); + relationInfo.setCapability(CAPABILITY_NAME); + relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID); + relationInfo.setRequirementUid(REQUIREMENT_UID); + relationInfo.setRequirement(REQUIREMENT_NAME); + RelationshipImpl relationshipImpl = new RelationshipImpl(); + relationshipImpl.setType(RELATIONSHIP_TYPE); + relationInfo.setRelationships(relationshipImpl); + } + + private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) { + return req.getRelationship().equals(relationshipInfo.getRelationship().getType()) && + req.getName().equals(relationshipInfo.getRequirement()) && + req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && + req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId()); + } + + private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) { + return cap.getName().equals(relationshipInfo.getCapability()) && + cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && + cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId()); + } + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationIntegrationTest.java new file mode 100644 index 0000000000..2740551b5c --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationIntegrationTest.java @@ -0,0 +1,133 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import static org.apache.commons.collections.ListUtils.union; +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class}) +public class PolicyOperationIntegrationTest extends ModelTestBase { + + private static final String CONTAINER_ID = "container"; + public static final String POLICY_ID = "policy"; + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + @Resource + private HealingJanusGraphDao janusGraphDao; + @Resource + private PolicyOperation policyOperation; + private PropertyDataDefinition prop1, prop2; + private PolicyDefinition policy; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + prop1 = new PropertyDataDefinition(); + prop1.setUniqueId("prop1"); + prop1.setName("prop1"); + prop1.setValue("prop1"); + + prop2 = new PropertyDataDefinition(); + prop2.setUniqueId("prop2"); + prop2.setName("prop2"); + prop2.setValue("prop2"); + + policy = new PolicyDefinition(); + policy.setUniqueId(POLICY_ID); + + policy.setProperties(Arrays.asList(prop1, prop2)); + + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + janusGraphDao.createVertex(resource); + GraphVertex loadedResource = janusGraphDao.getVertexById(CONTAINER_ID).left().value(); + topologyTemplateOperation.addToscaDataToToscaElement(loadedResource, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policy, JsonPresentationFields.UNIQUE_ID); +// janusGraphDao.commit(); + } + + @After + public void tearDown() { + janusGraphDao.rollback(); + } + + @Test + public void testUpdatePolicyProperties_singleProperty() { + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1NewValue"); + testUpdatePolicyProperties(Collections.singletonList(prop1Copy), Collections.singletonList(prop2)); + } + + @Test + public void testUpdatePolicyProperties_multipleProperties() { + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1NewValue"); + + PropertyDataDefinition prop2Copy = new PropertyDataDefinition(prop2); + prop2Copy.setValue("prop2NewValue"); + + testUpdatePolicyProperties(Arrays.asList(prop1Copy, prop2Copy), Collections.emptyList()); + } + + private void testUpdatePolicyProperties(List updatedProperties, List nonUpdatedPropeties) { + Component cmpt = new org.openecomp.sdc.be.model.Resource(); + cmpt.setUniqueId(CONTAINER_ID); + cmpt.setPolicies(Collections.singletonMap(POLICY_ID, policy)); + StorageOperationStatus storageOperationStatus = policyOperation.updatePolicyProperties(cmpt, POLICY_ID, updatedProperties); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + + ComponentParametersView componentParametersView = new ComponentParametersView(); + componentParametersView.disableAll(); + componentParametersView.setIgnorePolicies(false); + Either loadedCmptEither = topologyTemplateOperation.getToscaElement(CONTAINER_ID, componentParametersView); + + assertThat(loadedCmptEither.isLeft()).isTrue(); + ToscaElement loadedCmpt = loadedCmptEither.left().value(); + assertThat(loadedCmpt).isInstanceOf(TopologyTemplate.class); + @SuppressWarnings("unchecked") List allProperties = union(updatedProperties, nonUpdatedPropeties); + verifyPolicyPropertiesValuesUpdated((TopologyTemplate) loadedCmpt, allProperties); + } + + private void verifyPolicyPropertiesValuesUpdated(TopologyTemplate toscaElement, List expectedUpdatedProperties) { + Map policies = toscaElement.getPolicies(); + PolicyDataDefinition policy = policies.get(POLICY_ID); + List policyProperties = policy.getProperties(); + assertThat(policyProperties).usingElementComparatorOnFields("value") + .containsAll(expectedUpdatedProperties); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationTest.java new file mode 100644 index 0000000000..1df6721612 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/PolicyOperationTest.java @@ -0,0 +1,94 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +import java.util.Arrays; +import java.util.Collections; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class PolicyOperationTest { + + private static final String CONTAINER_ID = "containerId"; + private static final String POLICY_ID = "policyId"; + @InjectMocks + private PolicyOperation testInstance; + @Mock + private JanusGraphDao janusGraphDao; + @Mock + private TopologyTemplateOperation topologyTemplateOperation; + @Captor + private ArgumentCaptor policyDefCaptor; + private Component component; + private PolicyDefinition policyDefinition; + private PropertyDataDefinition prop1, prop2; + + @Before + public void setUp() throws Exception { + component = new Resource(); + component.setUniqueId(CONTAINER_ID); + policyDefinition = new PolicyDefinition(); + policyDefinition.setUniqueId(POLICY_ID); + prop1 = new PropertyDataDefinition(); + prop1.setName("prop1"); + prop1.setValue("prop1"); + + prop2 = new PropertyDataDefinition(); + prop2.setName("prop2"); + prop2.setValue("prop2"); + policyDefinition.setProperties(Arrays.asList(prop1, prop2)); + component.setPolicies(Collections.singletonMap(POLICY_ID, policyDefinition)); + } + + @Test + public void updatePolicyProperties_failedToFetchContainer() { + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + verifyZeroInteractions(topologyTemplateOperation); + } + + @Test + public void updatePolicyProperties_updateFailed() { + GraphVertex cmptVertex = new GraphVertex(); + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); + when(topologyTemplateOperation.updatePolicyOfToscaElement(cmptVertex, policyDefinition)).thenReturn(StorageOperationStatus.GENERAL_ERROR); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.GENERAL_ERROR); + } + + @Test + public void updatePolicyProperties() { + GraphVertex cmptVertex = new GraphVertex(); + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); + when(topologyTemplateOperation.updatePolicyOfToscaElement(eq(cmptVertex), policyDefCaptor.capture())).thenReturn(StorageOperationStatus.OK); + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1Copy"); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.singletonList(prop1Copy)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + assertThat(policyDefCaptor.getValue().getProperties()).usingElementComparatorOnFields("value") + .containsExactlyInAnyOrder(prop1Copy, prop2); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationCapabilityIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationCapabilityIntegrationTest.java new file mode 100644 index 0000000000..f5dd3a0346 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationCapabilityIntegrationTest.java @@ -0,0 +1,197 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class}) +public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTestBase { + + private static final String CONTAINER_ID = "id"; + private Map capabilitiesPropsMap; + private List capabilitiesProperties; + + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + + @Resource + private HealingJanusGraphDao janusGraphDao; + private CapabilityPropertyDataObject capabilityProperty1; + private CapabilityPropertyDataObject capabilityProperty2; + private CapabilityPropertyDataObject capabilityProperty3; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + + capabilitiesPropsMap = new HashMap<>(); + capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1"); + capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2"); + capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3"); + capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3); + + + //capablities props == Map>> + capabilitiesProperties.forEach(capabilitiesProperty -> { + capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabilityProperty(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue()))); + }); + + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + janusGraphDao.createVertex(resource); + GraphVertex loadedResource = janusGraphDao.getVertexById(CONTAINER_ID).left().value(); + topologyTemplateOperation.associateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value(); + } + + @After + public void tearDown() { + janusGraphDao.rollback(); + } + + @Test + public void overrideCalculatedCapabilityProperties() { + Map loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap); + capabilityProperty1.setPropValue("newVal1"); + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Map updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap); + } + + @Test + public void updateToscaDataDeepElementsBlockToToscaElement() { + assertCapabilityPropValue(capabilityProperty1, "val1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3"); + + MapCapabilityProperty instance1Props = capabilitiesPropsMap.get("instance1"); + capabilityProperty1.setPropValue("newVal1"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + + Component component = new org.openecomp.sdc.be.model.Resource(); + component.setUniqueId(CONTAINER_ID); + StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1"); + + assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK); + assertCapabilityPropValue(capabilityProperty1, "newVal1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated + } + + private Map fetchCapabilitiesProps(String containerId) { + ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true); + capabilityPropsFilter.setIgnoreCapabiltyProperties(false); + return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties(); + } + + private void compareCapabilitiesProperties(List expected, Map actual) { + expected.forEach(expectedCapabilityProp -> { + assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName)) + .isEqualTo(expectedCapabilityProp.propValue); + }); + } + + private String getPropertyValue(Map capabilityPropertyMap, String instance, String capability, String prop) { + return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue(); + } + + private void setPropertyValue(Map capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) { + setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty); + + } + + private void setPropertyValue(MapCapabilityProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) { + capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId()) + .getMapToscaDataDefinition().get(capabilityProperty.getPropName()) + .setValue(capabilityProperty.getPropValue()); + } + + private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) { + Map loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName()); + assertThat(propertyValue).isEqualTo(expectedValue); + } + + + private PropertyDefinition createPropWithValue(String val) { + PropertyDefinition propertyDefinition = new PropertyDefinition(); + propertyDefinition.setValue(val); + return propertyDefinition; + } + + private static class CapabilityPropertyDataObject { + private String instanceId; + private String capabilityId; + private String propName; + private String propValue; + + CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) { + this.instanceId = instanceId; + this.capabilityId = capabilityId; + this.propName = propName; + this.propValue = propValue; + } + + String getInstanceId() { + return instanceId; + } + + String getCapabilityId() { + return capabilityId; + } + + String getPropName() { + return propName; + } + + String getPropValue() { + return propValue; + } + + void setPropValue(String propValue) { + this.propValue = propValue; + } + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java new file mode 100644 index 0000000000..bc3c7cc8bd --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java @@ -0,0 +1,185 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.DistributionStatusEnum; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; + +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +//error scenarios +public class TopologyTemplateOperationTest { + + private static final String CONTAINER_ID = "containerId"; + @InjectMocks + private TopologyTemplateOperation topologyTemplateOperation; + @Mock + private JanusGraphDao janusGraphDao; + + @Test + public void overrideToscaDataOfToscaElement_failedToFetchContainerVertex() { + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right( + JanusGraphOperationStatus.INVALID_ID)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); + } + + @Test + public void overrideToscaDataOfToscaElement_failedToFetchDataVertex() { + GraphVertex containerVertex = new GraphVertex(); + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); + when(janusGraphDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void updateToscaDataDeepElements_failedToFetchContainerVertex() { + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right( + JanusGraphOperationStatus.INVALID_ID)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); + } + + @Test + public void updateToscaDataDeepElements_failedToFetchDataVertex() { + GraphVertex containerVertex = new GraphVertex(); + when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); + when(janusGraphDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void addPolicyToToscaElementSuccessTest(){ + JanusGraphOperationStatus status = JanusGraphOperationStatus.OK; + StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); + assertThat(result).isEqualTo(StorageOperationStatus.OK); + } + + @Test + public void addPolicyToToscaElementFailureTest(){ + JanusGraphOperationStatus status = JanusGraphOperationStatus.ALREADY_EXIST; + StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); + assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS); + } + + @Test + public void testAssociateOrAddCalcCapReqToComponent() { + StorageOperationStatus result; + GraphVertex graphVertex = new GraphVertex(); + Map calcRequirements = new HashMap<>(); + Map calcCapabilty = new HashMap<>(); + Map calCapabilitiesProps = new HashMap<>(); + addPolicyToToscaElementWithStatus(JanusGraphOperationStatus.OK); + result = topologyTemplateOperation.associateOrAddCalcCapReqToComponent(graphVertex, calcRequirements, calcCapabilty, calCapabilitiesProps); + assertEquals(StorageOperationStatus.OK, result); + } + + @Test + public void testSetDataTypesFromGraph() { + GraphVertex containerVertex = new GraphVertex(); + ComponentParametersView filter = new ComponentParametersView(true); + filter.setIgnoreComponentInstancesInterfaces(true); + filter.setIgnoreDataType(false); + String componentName = "componentName"; + String componentId = UniqueIdBuilder.buildResourceUniqueId(); + containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class)); + containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName); + containerVertex.setUniqueId(componentId); + containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + when(janusGraphDao.getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class))).thenReturn(Either.right( + JanusGraphOperationStatus.GENERAL_ERROR)); + Either storageOperationStatus = topologyTemplateOperation.getToscaElement(containerVertex, filter); + assertThat(storageOperationStatus).isEqualTo(Either.right(StorageOperationStatus.GENERAL_ERROR)); + } + + @Test + public void testUpdateDistributionStatus() { + Either result; + String uniqueId = "uniqueId"; + User user = new User(); + String userId = "userId"; + user.setUserId(userId); + Iterator edgeIterator = new Iterator() { + @Override + public boolean hasNext() { + return false; + } + + @Override + public Edge next() { + return null; + } + }; + GraphVertex graphVertex = Mockito.mock(GraphVertex.class); + JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class); + when(graphVertex.getVertex()).thenReturn(janusGraphVertex); + when(janusGraphVertex.edges(Direction.IN, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER.name())).thenReturn(edgeIterator); + when(janusGraphDao + .getVertexByPropertyAndLabel(GraphPropertyEnum.USERID, userId, VertexTypeEnum.USER, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); + when(janusGraphDao.getVertexById(uniqueId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex)); + when(janusGraphDao.createEdge(graphVertex, graphVertex, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER, null)).thenReturn( + JanusGraphOperationStatus.OK); + when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex)); + result = topologyTemplateOperation.updateDistributionStatus(uniqueId, user, DistributionStatusEnum.DISTRIBUTED); + assertThat(result.isLeft()); + } + + @SuppressWarnings("unchecked") + private StorageOperationStatus addPolicyToToscaElementWithStatus(JanusGraphOperationStatus status) { + GraphVertex componentV = new GraphVertex(); + componentV.setVertex(Mockito.mock(JanusGraphVertex.class)); + GraphVertex dataV = new GraphVertex(); + dataV.setVertex(Mockito.mock(JanusGraphVertex.class)); + String componentName = "componentName"; + String componentId = UniqueIdBuilder.buildResourceUniqueId(); + String policyTypeName = "org.openecomp.policies.placement.valet.Affinity"; + componentV.setJsonMetadataField(JsonPresentationFields.NAME, componentName); + componentV.setUniqueId(componentId); + PolicyDefinition policy = new PolicyDefinition(); + policy.setPolicyTypeName(policyTypeName); + int counter = 0; + Either toscaDataVertexRes = Either.right( + JanusGraphOperationStatus.NOT_FOUND); + when(janusGraphDao.getChildVertex(eq(componentV), eq(EdgeLabelEnum.POLICIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(toscaDataVertexRes); + Either createVertex = Either.left(dataV); + when(janusGraphDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex); + when(janusGraphDao.createEdge(any(JanusGraphVertex.class), any(JanusGraphVertex.class), any(EdgeLabelEnum.class), any(HashMap.class))).thenReturn(status); + return topologyTemplateOperation.addPolicyToToscaElement(componentV, policy, counter); + } + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationCatalogTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationCatalogTest.java new file mode 100644 index 0000000000..eeb7e17323 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationCatalogTest.java @@ -0,0 +1,73 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ToscaElementOperationCatalogTest { + + private ArrayList vertexList = new ArrayList<>(); + + @Mock + Vertex vertex; + @Mock + JanusGraphDao janusGraphDao; + @Mock + VertexProperty property; + + @InjectMocks + private ToscaElementOperation toscaOperation = new TopologyTemplateOperation(); + + @Before + public void setUp() { + vertexList.add(vertex); + when(janusGraphDao.getCatalogOrArchiveVerticies(true)).thenReturn(Either.left(vertexList.iterator())); + when(janusGraphDao.getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse)) + .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); + when(vertex.property(GraphPropertiesDictionary.METADATA.getProperty())).thenReturn(property); + } + + @Test + public void getComponentFromCatalogWhenDeleteIsTrue() { + final String vertexJsonIsDeletedTrue = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":true,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedTrue); + List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertTrue(componentList.isEmpty()); + } + + @Test + public void getComponentFromCatalogWhenDeleteNotFound() { + final String vertexJsonIsDeletedNotFound = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedNotFound); + List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertEquals(1, componentList.size()); + } + + @Test + public void getComponentFromCatalogWhenDeleteIsFalse() { + final String vertexJsonIsDeletedFalse = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":false,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedFalse); + List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertEquals(1, componentList.size()); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTest.java new file mode 100644 index 0000000000..205899d52f --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTest.java @@ -0,0 +1,363 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Created by chaya on 6/12/2017. + */ + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class ToscaElementOperationTest extends ModelTestBase{ + + private List allVertices = new ArrayList<>(); + private boolean isInitialized = false; + + @javax.annotation.Resource + private ToscaElementOperationTestImpl toscaElementOperation; + + @javax.annotation.Resource + private JanusGraphDao janusGraphDao; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + + } + + @Rule + public TestName testName = new TestName(); + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(janusGraphDao); + //exportGraphMl(janusGraphDao.getGraph().left().value(),""); + initGraphForTest(); + isInitialized = true; + } + } + + + @Test + public void testGetAllHighestResourcesNoFilter() { + + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, true); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + + + + @Test + public void testGetAllResourcesCertifiedNoFilter() { + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, false); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetHighestResourcesExclude() { + + // exclude VFCMT + List excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + + // exclude CP & VL + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + + // exclude CP & VL & VF & VFC + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + } + + @Test + public void testGetAllResourcesCertifiedExclude() { + // exclude VFCMT + List excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + + // exclude CP & VL + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + + // exclude CP & VL & VF & VFC + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + } + + @Test + public void testGetAllHighestServicesNoFilter() { + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, true); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetAllCertifiedServicesNoFilter() { + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, false); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetServicesExcludeList() { + List excludeList = Arrays.asList(ResourceTypeEnum.VF, ResourceTypeEnum.VFCMT); + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, true); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetCertifiedServicesExcludeList() { + List excludeList = Arrays.asList(ResourceTypeEnum.VL); + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, false); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, new HashMap() { + { + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testUpdateToscaElement_NotFound() { + Either result; + TopologyTemplate topologyTemplate = new TopologyTemplate(); + String userID = "userID"; + topologyTemplate.setLastUpdaterUserId(userID); + GraphVertex graphVertex = new GraphVertex(); + ComponentParametersView componentParametersView = new ComponentParametersView(); + result = toscaElementOperation.updateToscaElement(topologyTemplate, graphVertex, componentParametersView); + assertEquals(null, result); + } + + private boolean genericTestGetResourcesWithExcludeList(List excludeList) { + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE,excludeList, true); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + } + }, new HashMap() { + { + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + return highestResources.stream().count() == (highestResourcesExpectedCount); + } + + private boolean genericTestGetCertifiedResourcesWithExcludeList(List excludeList) { + Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludeList, false); + assertTrue(highestResourcesRes.isLeft()); + List highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, new HashMap() { + { + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + highestResourcesExpectedCount += calculateCount(new HashMap() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + return highestResources.stream().count() == highestResourcesExpectedCount; + } + + private void initGraphForTest() { + GraphTestUtils.createRootCatalogVertex(janusGraphDao); + + Map highstVerticesProps = new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }; + + Map certifiedVerticesProps = new HashMap() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }; + + // add vertices with higestVersion = true + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, highstVerticesProps, ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, highstVerticesProps, ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, highstVerticesProps, ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, highstVerticesProps, ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, highstVerticesProps, ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(janusGraphDao, highstVerticesProps)); + + // add vertices with non-additional properties + for (int i=0 ; i<2 ; i++) { + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, new HashMap<>(), ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, new HashMap<>(), ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, new HashMap<>(), ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, new HashMap<>(), ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, new HashMap<>(), ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>())); + } + + // add certified vertices + for (int i=0; i<3; i++) { + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, certifiedVerticesProps, ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, certifiedVerticesProps, ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, certifiedVerticesProps, ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, certifiedVerticesProps, ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(janusGraphDao, certifiedVerticesProps, ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(janusGraphDao, certifiedVerticesProps)); + } + //allVertices.stream().forEach( v -> System.out.println("type: "+v.getMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE))); + //String result = GraphTestUtils.exportGraphMl(janusGraphDao.getGraph().left().value(), ""); + //System.out.println("graph is: " + result); + } + + private long calculateCount(HashMap hasProps, Map doesntHaveProps){ + return allVertices.stream(). + filter(v -> { + Map vertexProps = v.getMetadataProperties(); + if (hasProps != null) { + for (Map.Entry prop: hasProps.entrySet()){ + Object value = vertexProps.get(prop.getKey()); + if ( value == null || !value.equals(prop.getValue())) { + return false; + } + } + } + + if (doesntHaveProps != null) { + for (Map.Entry prop : doesntHaveProps.entrySet()) { + Object value = vertexProps.get(prop.getKey()); + Object propValue = prop.getValue(); + if ( value != null && propValue != null && propValue instanceof List ) { + for (ResourceTypeEnum propVal : (List)propValue) { + if (propVal.name().equals(value)) { + return false; + } + } + } + else if (value != null && value.equals(propValue)){ + return false; + } + } + } + return true; + }).count(); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTestImpl.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTestImpl.java new file mode 100644 index 0000000000..01e14cd588 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaElementOperationTestImpl.java @@ -0,0 +1,74 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +/** + * Created by cb478c on 6/13/2017. + */ +@org.springframework.stereotype.Component("test-tosca-element-operation") +public class ToscaElementOperationTestImpl extends ToscaElementOperation { + + @Override + protected Either getLightComponent(GraphVertex vertexComponent, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { + janusGraphDao.parseVertexProperties(vertexComponent, JsonParseFlagEnum.ParseMetadata); + T toscaElement = convertToComponent(vertexComponent); + return Either.left(toscaElement); + } + + @Override + public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { + return null; + } + + @Override + public Either getToscaElement(GraphVertex toscaElementVertex, ComponentParametersView componentParametersView) { + return null; + } + + @Override + public Either deleteToscaElement(GraphVertex toscaElementVertex) { + return null; + } + + @Override + public Either createToscaElement(ToscaElement toscaElement) { + return null; + } + + @Override + protected JanusGraphOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { + return null; + } + + @Override + protected JanusGraphOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { + return null; + } + + @Override + protected JanusGraphOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { + return null; + } + + @Override + protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { + return null; + } + + @Override + protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex updateElementV) { + return null; + } + + @Override + public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { + + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadePoliciesTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadePoliciesTest.java new file mode 100644 index 0000000000..88d3db68c6 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadePoliciesTest.java @@ -0,0 +1,134 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertTrue; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class}) +public class ToscaOperationFacadePoliciesTest extends ModelTestBase { + + @Autowired + private ToscaOperationFacade toscaOperationFacade; + @Autowired + private HealingJanusGraphDao janusGraphDao; + + private PolicyDefinition policy1, policy2; + + @BeforeClass + public static void setupBeforeClass() { + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + policy1 = createPolicyDefinition("type1"); + policy2 = createPolicyDefinition("type2"); + createContainerVertexInDB(); + createPoliciesOnGraph(policy1, policy2); + } + + private void createPoliciesOnGraph(PolicyDefinition ... policies) { + for (int i = 0; i < policies.length; i++) { + PolicyDefinition policy = policies[i]; + Either createdPolicy = toscaOperationFacade.associatePolicyToComponent(CONTAINER_ID, policy, i); + assertTrue(createdPolicy.isLeft()); + } + } + + @After + public void tearDown() { + janusGraphDao.rollback(); + } + + @Test + public void updatePoliciesTargetsOfComponent_updateSinglePolicy() { + List updatedTargetIds = asList("instance1new", "instance2"); + PolicyDefinition originalPolicy2 = clonePolicyWithTargets(policy2); + updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + + StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, singletonList(policy1)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Component updatedComponent = fetchComponentFromDB(); + verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); + verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), originalPolicy2); + } + + @Test + public void updatePoliciesTargetsOfComponent_updateMultiplePolicies() { + List updatedTargetIds = asList("instance1new", "instance2"); + updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, asList(policy1, policy2)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Component updatedComponent = fetchComponentFromDB(); + verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); + verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), policy2); + } + + private PolicyDefinition clonePolicyWithTargets(PolicyDefinition policy) { + PolicyDefinition originalPolicy = new PolicyDefinition(policy); + Map> clonedTargetMap = policy.getTargets().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> new ArrayList<>(entry.getValue()))); + originalPolicy.setTargets(clonedTargetMap); + return originalPolicy; + } + + private void verifyPolicyTargets(PolicyDefinition updatedPolicy, PolicyDefinition expectedPolicy) { + assertThat(updatedPolicy.getTargets()) + .isEqualTo(expectedPolicy.getTargets()); + } + + private void updatePolicyTypeTargetsIds(PolicyDefinition policy, PolicyTargetType targetType, List updatedTargetIds) { + policy.getTargets().put(targetType, updatedTargetIds); + } + + private Component fetchComponentFromDB() { + ComponentParametersView componentParametersView = new ComponentParametersView(); + componentParametersView.disableAll(); + componentParametersView.setIgnorePolicies(false); + return toscaOperationFacade.getToscaElement(CONTAINER_ID, componentParametersView).left().value(); + } + + private void createContainerVertexInDB() { + GraphVertex resource = createBasicContainerGraphVertex(); + Either container = janusGraphDao.createVertex(resource); + assertTrue(container.isLeft()); + } + + private PolicyDefinition createPolicyDefinition(String type) { + PolicyDefinition policy = new PolicyDefinition(); + policy.setPolicyTypeName(type); + policy.setTargets(new HashMap<>()); + policy.getTargets().put(PolicyTargetType.COMPONENT_INSTANCES, asList("instance1", "instance2")); + return policy; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java new file mode 100644 index 0000000000..1bbbd1c087 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java @@ -0,0 +1,692 @@ +/* + + * Copyright (c) 2018 AT&T Intellectual Property. + + * + + * Licensed under the Apache License, Version 2.0 (the "License"); + + * you may not use this file except in compliance with the License. + + * You may obtain a copy of the License at + + * + + * http://www.apache.org/licenses/LICENSE-2.0 + + * + + * Unless required by applicable law or agreed to in writing, software + + * distributed under the License is distributed on an "AS IS" BASIS, + + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + + * See the License for the specific language governing permissions and + + * limitations under the License. + + */ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.ArgumentMatchers; +import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.DataTypeDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.Collections; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; + +@RunWith(MockitoJUnitRunner.class) +public class ToscaOperationFacadeTest { + private static final String COMPONENT_ID = "componentId"; + private static final String PROPERTY1_NAME = "prop1"; + private static final String PROPERTY1_TYPE = "string"; + private static final String PROPERTY2_NAME = "prop2"; + private static final String PROPERTY2_TYPE = "integer"; + + @InjectMocks + private ToscaOperationFacade testInstance; + + @Mock + private HealingJanusGraphDao janusGraphDaoMock; + + @Mock + private TopologyTemplateOperation topologyTemplateOperationMock; + + @Mock + private NodeTypeOperation nodeTypeOperation; + + @Mock + private NodeTemplateOperation nodeTemplateOperationMock; + + @Before + public void setUp() throws Exception { + testInstance = new ToscaOperationFacade(); + MockitoAnnotations.initMocks(this); + } + + @SuppressWarnings("unchecked") + @Test + public void fetchMetaDataByResourceType() throws Exception { + ArgumentCaptor criteriaCapture = ArgumentCaptor.forClass(Map.class); + ArgumentCaptor criteriaNotCapture = ArgumentCaptor.forClass(Map.class); + ComponentParametersView dataFilter = new ComponentParametersView(); + List mockVertices = getMockVertices(2); + Either, JanusGraphOperationStatus> returnedVertices = Either.left(mockVertices); + + when(janusGraphDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices); + when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0"))); + when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1"))); + Either, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter); + + verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture); + verifyCriteriaNotIsDeleted(criteriaNotCapture); + + assertTrue(fetchedComponents.isLeft()); + List cmpts = fetchedComponents.left().value(); + assertEquals(2, cmpts.size()); + assertEquals("0", cmpts.get(0).getUniqueId()); + assertEquals("1", cmpts.get(1).getUniqueId()); + } + + private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor criteriaCapture) { + Map criteria = (Map)criteriaCapture.getValue(); + assertEquals(2, criteria.size()); + assertEquals(criteria.get(GraphPropertyEnum.RESOURCE_TYPE), "VF"); + assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true); + } + + private void verifyCriteriaNotIsDeleted(ArgumentCaptor criteriaNotCapture) { + Map notCriteria = (Map)criteriaNotCapture.getValue(); + assertEquals(1, notCriteria.size()); + assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true); + } + + @SuppressWarnings("unchecked") + @Test + public void fetchMetaDataByResourceType_failedToGetData() throws Exception { + when(janusGraphDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right( + JanusGraphOperationStatus.GENERAL_ERROR)); + Either, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView()); + assertTrue(fetchedComponents.isRight()); + assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value()); + } + + @Test + public void associatePolicyToComponentSuccessTest(){ + Either result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); + } + + @Test + public void associatePolicyToComponentFailureTest(){ + Either result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); + } + + @Test + public void updatePolicyOfComponentSuccessTest(){ + Either result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); + } + + @Test + public void updatePolicyOfComponentFailureTest(){ + Either result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); + } + + @Test + public void removePolicyFromComponentSuccessTest(){ + removePolicyFromComponentWithStatus(StorageOperationStatus.OK); + } + + @Test + public void removePolicyFromComponentFailureTest(){ + removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void testFindLastCertifiedToscaElementByUUID(){ + Either result; + Component component = new Resource(); + List list = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + list.add(graphVertex); + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.UUID, component.getUUID()); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + ToscaElement toscaElement = getToscaElementForTest(); + when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + when(janusGraphDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list)); + result = testInstance.findLastCertifiedToscaElementByUUID(component); + Component resultComp = result.left().value(); + assertEquals(resultComp.getToscaType(),ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); + } + + @Test + public void testLatestComponentByToscaResourceName(){ + Either result; + TopologyTemplate toscaElement = new TopologyTemplate(); + toscaElement.setComponentType(ComponentTypeEnum.SERVICE); + List list = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + Map props = new HashMap<>(); + props.put(GraphPropertyEnum.VERSION, "1.0"); + graphVertex.setMetadataProperties(props); + list.add(graphVertex); + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName"); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(list)); + when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + + result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName"); + assertThat(result.isLeft()); + } + + @Test + public void testValidateCsarUuidUniqueness() { + StorageOperationStatus result; + String csarUUID = "csarUUID"; + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); + List vertexList = new ArrayList<>(); + when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList)); + result = testInstance.validateCsarUuidUniqueness(csarUUID); + assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result); + } + + @Test + public void testValidateCsarUuidUnique_true() { + StorageOperationStatus result; + String csarUUID = "csarUUID"; + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); + when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + result = testInstance.validateCsarUuidUniqueness(csarUUID); + assertEquals(StorageOperationStatus.OK, result); + } + + @Test + public void testGetLatestCertiNodeTypeByToscaResourceName() { + Either result; + String toscaResourceName = "resourceName"; + String uniqueId = "uniqueId"; + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0"); + graphVertex.setUniqueId(uniqueId); + List vertexList = new ArrayList<>(); + vertexList.add(graphVertex); + Map props = new EnumMap<>(GraphPropertyEnum.class); + props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + ToscaElement topologyTemplate = new TopologyTemplate(); + topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); + when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList)); + when(janusGraphDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); + when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(topologyTemplate)); + result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName); + assertThat(result.isLeft()); + } + + @Test + public void testValidateCompExists() { + Either result; + String componentId = "componentId"; + GraphVertex graphVertex = getTopologyTemplateVertex(); + when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); + result = testInstance.validateComponentExists(componentId); + assertEquals(true, result.left().value()); + } + + @Test + public void testValidateCompExists_NotFound() { + Either result; + String componentId = "componentId"; + when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + result = testInstance.validateComponentExists(componentId); + assertEquals(false, result.left().value()); + } + + @Test + public void testValidateToscaResourceNameExists() { + Either result; + String templateName = "templateName"; + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName); + List graphVertexList = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertexList.add(graphVertex); + when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList)); + result = testInstance.validateToscaResourceNameExists(templateName); + assertEquals(true, result.left().value()); + } + + @Test + public void testValidateToscaResourceNameExists_false() { + Either result; + String templateName = "templateName"; + Map properties = new EnumMap<>(GraphPropertyEnum.class); + properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName); + List graphVertexList = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertexList.add(graphVertex); + when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + result = testInstance.validateToscaResourceNameExists(templateName); + assertEquals(false, result.left().value()); + } + + @Test + public void testOverrideComponent() { + Either result; + Resource resource = new Resource(); + String id = "id"; + resource.setUniqueId(id); + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + NodeType nodeType = new NodeType(); + nodeType.setComponentType(ComponentTypeEnum.RESOURCE); + ToscaElement toscaElement = new TopologyTemplate(); + toscaElement.setComponentType(ComponentTypeEnum.SERVICE); + when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); + when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); + when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement)); + when(nodeTypeOperation.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType)); + when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); + when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn( + JanusGraphOperationStatus.OK); + result = testInstance.overrideComponent(resource, resource); + assertTrue(result.isLeft()); + } + + @Test + public void testGetToscaElement() { + Either result; + String id = "id"; + GraphVertex graphVertex = getTopologyTemplateVertex(); + ToscaElement toscaElement = getToscaElementForTest(); + when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); + when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll); + assertTrue(result.isLeft()); + } + + @Test + public void testMarkComponentToDelete() { + StorageOperationStatus result; + Component component = new Resource(); + String id = "id"; + component.setUniqueId(id); + GraphVertex graphVertex = getTopologyTemplateVertex(); + when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); + when(nodeTypeOperation.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex)); + result = testInstance.markComponentToDelete(component); + assertEquals(result, StorageOperationStatus.OK); + } + + @Test + public void testDelToscaComponent() { + Either result; + String componentId = "compId"; + GraphVertex graphVertex = getTopologyTemplateVertex(); + ToscaElement toscaElement = getToscaElementForTest(); + when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); + when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement)); + result = testInstance.deleteToscaComponent(componentId); + assertTrue(result.isLeft()); + } + + @Test + public void testGetLatestByToscaResourceName() { + Either result; + String toscaResourceName = "name"; + ToscaElement toscaElement = getToscaElementForTest(); + + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); + propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + List graphVertexList = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertex.setUniqueId(toscaResourceName); + Map props = new HashMap<>(); + props.put(GraphPropertyEnum.VERSION, "1.0"); + graphVertex.setMetadataProperties(props); + graphVertexList.add(graphVertex); + + when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList)); + when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + result = testInstance.getLatestByToscaResourceName(toscaResourceName); + assertTrue(result.isLeft()); + } + + @Test + public void testGetFollowed() { + Either, StorageOperationStatus> result; + String userId = "id"; + Set lifecycleStates = new HashSet<>(); + Set lastStateStates = new HashSet<>(); + lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + lifecycleStates.add(LifecycleStateEnum.READY_FOR_CERTIFICATION); + lifecycleStates.add(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); + lifecycleStates.add(LifecycleStateEnum.CERTIFIED); + lastStateStates.add(LifecycleStateEnum.READY_FOR_CERTIFICATION); + ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE; + List toscaEleList = new ArrayList<>(); + ToscaElement toscaElement = getToscaElementForTest(); + toscaEleList.add(toscaElement); + when(nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType)).thenReturn(Either.left(toscaEleList)); + result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType); + assertTrue(result.isLeft()); + assertEquals(1, result.left().value().size()); + } + + @Test + public void testGetBySystemName() { + Either, StorageOperationStatus> result; + String sysName = "sysName"; + ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; + ToscaElement toscaElement = getToscaElementForTest(); + List componentVertices = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + componentVertices.add(graphVertex); + Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); + Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); + + propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName); + propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name()); + + propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); + + when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertices)); + when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + result = testInstance.getBySystemName(componentTypeEnum, sysName); + assertTrue(result.isLeft()); + assertEquals(1, result.left().value().size()); + } + + @Test + public void testGetCompByNameAndVersion() { + Either result; + ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE; + String name = "name"; + String version = "1.0"; + JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll; + List graphVertexList = new ArrayList<>(); + GraphVertex graphVertex = getTopologyTemplateVertex(); + graphVertexList.add(graphVertex); + ToscaElement toscaElement = getToscaElementForTest(); + Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); + Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); + + hasProperties.put(GraphPropertyEnum.NAME, name); + hasProperties.put(GraphPropertyEnum.VERSION, version); + hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); + hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); + when(janusGraphDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList)); + when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); + result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag); + assertTrue(result.isLeft()); + } + + private ToscaElement getToscaElementForTest() { + ToscaElement toscaElement = new TopologyTemplate(); + toscaElement.setComponentType(ComponentTypeEnum.RESOURCE); + return toscaElement; + } + + @Test + public void addDataTypesToComponentSuccessTest(){ + Either, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); + } + + @Test + public void addDataTypesToComponentFailureTest_BadRequest(){ + Either, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); + } + + private Either, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) { + Map dataTypes = new HashMap<>(); + String componentId = "componentid"; + String Id = "id"; + + PropertyDefinition noDefaultProp = new PropertyDefinition(); + noDefaultProp.setName("noDefaultProp"); + PropertyDefinition prop1 = new PropertyDefinition(); + prop1.setDefaultValue("def1"); + prop1.setName("prop1"); + PropertyDefinition prop2 = new PropertyDefinition(); + prop2.setType("dataType1"); + prop2.setName("prop2"); + PropertyDefinition prop3 = new PropertyDefinition(); + prop3.setDefaultValue("def3"); + prop3.setName("prop3"); + + DataTypeDefinition noDefaultValue = new DataTypeDefinition(); + noDefaultValue.setProperties(Collections.singletonList(noDefaultProp)); + noDefaultValue.setDerivedFromName("name0"); + + DataTypeDefinition dataType1 = new DataTypeDefinition(); + dataType1.setProperties(Arrays.asList(prop1, prop3)); + dataType1.setName("name1"); + dataType1.setDerivedFromName("derivedfromname1"); + + DataTypeDefinition dataType2 = new DataTypeDefinition(); + dataType2.setDerivedFrom(dataType1); + dataType2.setName("name2"); + dataType2.setDerivedFromName("derivedfromname2"); + + DataTypeDefinition dataType3 = new DataTypeDefinition(); + dataType3.setProperties(Collections.singletonList(prop2)); + dataType3.setDerivedFrom(noDefaultValue); + dataType3.setName("name3"); + dataType3.setDerivedFromName("derivedfromname3"); + + dataTypes.put("noDefault", noDefaultValue); + dataTypes.put("dataType1", dataType1); + dataTypes.put("dataType2", dataType2); + dataTypes.put("dataType3", dataType3); + + GraphVertex vertex; + if(status == StorageOperationStatus.OK){ + vertex = getTopologyTemplateVertex(); + } else { + vertex = getNodeTypeVertex(); + } + Either getVertexEither = Either.left(vertex); + when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither); + when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex), + eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status); + return testInstance.addDataTypesToComponent(dataTypes, componentId); + } + + @Test + public void testDataTypesToComponentFailureTest_NotFound() { + Either, StorageOperationStatus> result; + String componentId = "componentId"; + GraphVertex vertex = getNodeTypeVertex(); + Map dataTypes = new HashMap<>(); + when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right( + JanusGraphOperationStatus.NOT_FOUND)); + result = testInstance.addDataTypesToComponent(dataTypes, componentId); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); + } + + @Test + public void testDeleteDataTypeOfComponent() { + StorageOperationStatus result; + Component component = new Resource(); + String id = "id"; + component.setUniqueId(id); + String datatype = null; + + DataTypeDefinition dataType1 = new DataTypeDefinition(); + dataType1.setName("name1"); + Map dataTypeDataMap = new HashMap<>(); + dataTypeDataMap.put("datatype1", dataType1); + List dataTypeMap = dataTypeDataMap.values().stream().map(e -> { DataTypeDefinition dataType = new DataTypeDefinition(e);return dataType; }).collect(Collectors.toList()); + component.setDataTypes(dataTypeMap); + GraphVertex graphVertex = getTopologyTemplateVertex(); + result = testInstance.deleteDataTypeOfComponent(component, "datatype1"); + assertEquals(datatype, result); + } + + @Test + public void testAddComponentInstancePropertiesToComponent() { + // set up component object + Component component = new Resource(); + component.setUniqueId(COMPONENT_ID); + List instanceProps = new ArrayList<>(); + ComponentInstanceProperty instanceProp = new ComponentInstanceProperty(); + instanceProp.setName(PROPERTY1_NAME); + instanceProp.setType(PROPERTY1_TYPE); + instanceProps.add(instanceProp); + instanceProp = new ComponentInstanceProperty(); + instanceProp.setName(PROPERTY2_NAME); + instanceProp.setType(PROPERTY2_TYPE); + instanceProps.add(instanceProp); + Map> instancePropsMap = + Collections.singletonMap(COMPONENT_ID, instanceProps); + component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>())); + + when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any())) + .thenReturn(StorageOperationStatus.OK); + + Either>, StorageOperationStatus> result = + testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap); + assertTrue(result.isLeft()); + verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any()); + List resultProps = result.left().value().get(COMPONENT_ID); + assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME))); + assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME))); + } + + private Either associatePolicyToComponentWithStatus(StorageOperationStatus status) { + PolicyDefinition policy = new PolicyDefinition(); + String componentId = "componentId"; + int counter = 0; + GraphVertex vertex; + if(status == StorageOperationStatus.OK){ + vertex = getTopologyTemplateVertex(); + } else { + vertex = getNodeTypeVertex(); + } + Either getVertexEither = Either.left(vertex); + when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither); + when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status); + return testInstance.associatePolicyToComponent(componentId, policy, counter); + } + + private Either updatePolicyOfComponentWithStatus(StorageOperationStatus status) { + PolicyDefinition policy = new PolicyDefinition(); + String componentId = "componentId"; + GraphVertex vertex = getTopologyTemplateVertex(); + when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex)); + when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status); + return testInstance.updatePolicyOfComponent(componentId, policy); + } + + private void removePolicyFromComponentWithStatus(StorageOperationStatus status) { + String componentId = "componentId"; + String policyId = "policyId"; + GraphVertex vertex = getTopologyTemplateVertex(); + Either getVertexEither = Either.left(vertex); + when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither); + when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status); + StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId); + assertSame(result, status); + } + + private List getMockVertices(int numOfVertices) { + return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList()); + } + + private ToscaElement getResourceToscaElement(String id) { + ToscaElement toscaElement = new TopologyTemplate(); + toscaElement.setMetadata(new HashMap<>()); + toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE"); + toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id); + return toscaElement; + } + + private GraphVertex getTopologyTemplateVertex() { + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + return graphVertex; + } + + private GraphVertex getNodeTypeVertex() { + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.NODE_TYPE); + return graphVertex; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperationTest.java new file mode 100644 index 0000000000..68c87bb7e8 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/UpgradeOperationTest.java @@ -0,0 +1,183 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.operations; + +import fj.data.Either; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.category.SubCategoryDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.operations.api.IElementOperation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class UpgradeOperationTest extends ModelTestBase { + + private boolean isInitialized; + @Resource + private JanusGraphDao janusGraphDao; + @Resource + private UpgradeOperation upgradeOperation; + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + @Resource + private NodeTemplateOperation nodeTemplateOperation; + @Resource + private UserAdminOperation userAdminOperation; + @javax.annotation.Resource + private IElementOperation elementOperation; + + private User user; + + private CategoryDefinition resourceCategory; + private CategoryDefinition serviceCategory; + + + @BeforeClass + public static void initTest() { + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(janusGraphDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testGetSimpleDependency() { + + TopologyTemplate vf = createVf("vf1"); + + TopologyTemplate service = createServiceWitnInstance("service1", vf); + + + Either, StorageOperationStatus> result = upgradeOperation.getComponentDependencies(vf.getUniqueId()); + assertThat(result.isLeft()).isTrue(); + List dependencies = result.left().value(); + assertThat(dependencies).hasSize(1); + + ComponentDependency dependency = dependencies.get(0); + assertThat(dependency.getName()).isEqualTo(vf.getName()); + assertThat(dependency.getVersion()).isEqualTo(vf.getVersion()); + assertThat(dependency.getDependencies()).hasSize(1); + + ComponentDependency container = dependency.getDependencies().get(0); + assertThat(container.getName()).isEqualTo(service.getName()); + assertThat(container.getVersion()).isEqualTo(service.getVersion()); + assertThat(container.getDependencies()).isNull(); + + } + + /******************************* + * Preperation Methods + *******************************/ + private void initGraphForTest() { + + user = new User("Jim", "Tom", "jt123a", "1@mail.com", "DESIGNER", System.currentTimeMillis()); + Either saveUserData = userAdminOperation.saveUserData(user); + assertThat(saveUserData.isLeft()).isTrue(); + + GraphTestUtils.createRootCatalogVertex(janusGraphDao); + resourceCategory = createResourceCategories(); + serviceCategory = createServiceCategory(); + + } + + private TopologyTemplate createServiceWitnInstance(String name, TopologyTemplate createdVf) { + + TopologyTemplate serviceNew = createTopologyTemplate(ComponentTypeEnum.SERVICE, name); + List categoriesService = new ArrayList<>(); + categoriesService.add(serviceCategory); + serviceNew.setCategories(categoriesService); + + Either createService = topologyTemplateOperation.createTopologyTemplate(serviceNew); + assertThat(createService.isLeft()).isTrue(); + + ComponentInstance vfInstance = new ComponentInstance(); + vfInstance.setUniqueId(createdVf.getUniqueId() + createdVf.getName()); + vfInstance.setComponentUid(createdVf.getUniqueId()); + vfInstance.setName(createdVf.getName()); + Either, StorageOperationStatus> addInstance = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(serviceNew, createdVf, "0", vfInstance, false, user); + assertThat(addInstance.isLeft()).isTrue(); + return serviceNew; + } + + private CategoryDefinition createServiceCategory() { + CategoryDefinition categoryService = new CategoryDefinition(); + categoryService.setName("servicecategory"); + categoryService.setNormalizedName("servicecategory"); + categoryService.setUniqueId("servicecategory"); + Either createCategory = elementOperation.createCategory(categoryService , NodeTypeEnum.ServiceNewCategory); + + assertThat(createCategory.isLeft()).isTrue(); + return categoryService; + } + + private TopologyTemplate createVf(String name) { + + TopologyTemplate resource = createTopologyTemplate(ComponentTypeEnum.RESOURCE, name); + + resource.setResourceType(ResourceTypeEnum.VF); + List categories = new ArrayList<>(); + categories.add(resourceCategory); + resource.setCategories(categories); + Either createVf = topologyTemplateOperation.createTopologyTemplate(resource); + assertThat( createVf.isLeft()).isTrue(); + return resource; + } + + private CategoryDefinition createResourceCategories() { + CategoryDefinition category = new CategoryDefinition(); + category.setName("category1"); + category.setNormalizedName("category1"); + category.setUniqueId("category1"); + Either createCategory = elementOperation.createCategory(category , NodeTypeEnum.ResourceNewCategory); + assertThat(createCategory.isLeft()).isTrue(); + + SubCategoryDefinition subCategory = new SubCategoryDefinition(); + + subCategory.setName("subcategory1"); + subCategory.setNormalizedName("subcategory1"); + subCategory.setUniqueId("subcategory1"); + elementOperation.createSubCategory(createCategory.left().value().getUniqueId(), subCategory, NodeTypeEnum.ResourceSubcategory); + category.addSubCategory(subCategory); + return category; + } + + private TopologyTemplate createTopologyTemplate(ComponentTypeEnum type, String name) { + TopologyTemplate template = new TopologyTemplate(); + template.setUniqueId(IdBuilderUtils.generateUniqueId()); + template.setComponentType(type); + template.setHighestVersion(true); + template.setLifecycleState(LifecycleStateEnum.CERTIFIED); + template.setMetadataValue(JsonPresentationFields.NAME, name); + template.setMetadataValue(JsonPresentationFields.VERSION, "1.0"); + template.setCreatorUserId(user.getUserId()); + return template; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityTestUtils.java new file mode 100644 index 0000000000..8a17de4054 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/CapabilityTestUtils.java @@ -0,0 +1,85 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class CapabilityTestUtils { + + public static Map createCapPropsForTopologyTemplate(TopologyTemplate topologyTemplate) { + Map capabilitiesMap = new HashMap<>(); + + List capabilityDefinitions = new ArrayList<>(); + CapabilityDefinition capabilityDefinition = createCapabilityDefinition(); + + capabilityDefinitions.add(capabilityDefinition); + ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capabilityDefinitions); + capabilitiesMap.put(capabilityDefinition.getType(), listCapabilityDataDefinition); + topologyTemplate.setCapabilities(capabilitiesMap); + + List capPropList = new ArrayList<>(); + ComponentInstanceProperty instanceProperty = createProperties(); + capPropList.add(instanceProperty); + + MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + for (ComponentInstanceProperty cip : capPropList) { + PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip); + dataToCreate.put(cip.getName(), propertyDataDefinition); + } + + Map capabilitiesProperties = new HashMap<>(); + capabilitiesProperties.put(capabilityDefinition.getType() + ModelConverter.CAP_PROP_DELIM + + capabilityDefinition.getName(), dataToCreate); + return capabilitiesProperties; + } + + private static CapabilityDefinition createCapabilityDefinition() { + CapabilityDefinition capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setName("cap" + Math.random()); + capabilityDefinition.setType("tosca.capabilities.network.Bindable"); + capabilityDefinition.setOwnerId("resourceId"); + capabilityDefinition.setUniqueId("capUniqueId"); + List path = new ArrayList<>(); + path.add("path1"); + capabilityDefinition.setPath(path); + return capabilityDefinition; + } + + private static ComponentInstanceProperty createProperties() { + ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty(); + instanceProperty.setUniqueId("ComponentInput1_uniqueId"); + instanceProperty.setType("Integer"); + instanceProperty.setName("prop_name"); + instanceProperty.setDescription("prop_description_prop_desc"); + instanceProperty.setOwnerId("capUniqueId"); + instanceProperty.setValue("{\"get_input\":\"extcp20_order\"}"); + instanceProperty.setSchema(new SchemaDefinition()); + return instanceProperty; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/GraphTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/GraphTestUtils.java new file mode 100644 index 0000000000..06e0b428b9 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/GraphTestUtils.java @@ -0,0 +1,129 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.io.IoCore; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.util.Iterator; +import java.util.Map; +import java.util.UUID; + +public final class GraphTestUtils { + + public static GraphVertex createRootCatalogVertex(JanusGraphDao janusGraphDao) { + GraphVertex catalogRootVertex = new GraphVertex(VertexTypeEnum.CATALOG_ROOT); + catalogRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); + return janusGraphDao.createVertex(catalogRootVertex) + .either(v -> v, s -> null); + } + + public static GraphVertex createRootArchiveVertex(JanusGraphDao janusGraphDao) { + GraphVertex archiveRootVertex = new GraphVertex(VertexTypeEnum.ARCHIVE_ROOT); + archiveRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); + return janusGraphDao.createVertex(archiveRootVertex) + .either(v -> v, s -> null); + } + + public static GraphVertex createResourceVertex(JanusGraphDao janusGraphDao, Map metadataProps, ResourceTypeEnum type) { + GraphVertex vertex = new GraphVertex(); + if (type == ResourceTypeEnum.VF) { + vertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); + } else { + vertex.setLabel(VertexTypeEnum.NODE_TYPE); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.NODE_TYPE); + } + String uuid = UUID.randomUUID().toString(); + vertex.setUniqueId(uuid); + + vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); + vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + vertex.addMetadataProperty(GraphPropertyEnum.RESOURCE_TYPE, type.name()); + vertex.addMetadataProperty(GraphPropertyEnum.IS_ABSTRACT, false); + for (Map.Entry prop : metadataProps.entrySet()) { + vertex.addMetadataProperty(prop.getKey(), prop.getValue()); + } + janusGraphDao.createVertex(vertex); + janusGraphDao.commit(); + return vertex; + } + + public static GraphVertex createServiceVertex(JanusGraphDao janusGraphDao, Map metadataProps){ + GraphVertex vertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + String uuid = UUID.randomUUID().toString(); + vertex.setUniqueId(uuid); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); + vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); + vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + for (Map.Entry prop : metadataProps.entrySet()) { + vertex.addMetadataProperty(prop.getKey(), prop.getValue()); + } + janusGraphDao.createVertex(vertex); + janusGraphDao.commit(); + return vertex; + } + + public static void clearGraph(JanusGraphDao janusGraphDao) { + Either graphResult = janusGraphDao.getGraph(); + JanusGraph graph = graphResult.left().value(); + + Iterable vertices = graph.query().vertices(); + if (vertices != null) { + Iterator iterator = vertices.iterator(); + while (iterator.hasNext()) { + JanusGraphVertex vertex = iterator.next(); + vertex.remove(); + } + } + janusGraphDao.commit(); + } + + public static String exportGraphMl(JanusGraph graph, String outputDirectory) { + String result = null; + String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml"; + try { + try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) { + graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph); + } + result = outputFile; + graph.tx().commit(); + } catch (Exception e) { + graph.tx().rollback(); + e.printStackTrace(); + } + return result; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapperTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapperTest.java new file mode 100644 index 0000000000..dca79c6041 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/IdMapperTest.java @@ -0,0 +1,37 @@ +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.junit.Test; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; + +public class IdMapperTest { + + private IdMapper createTestSubject() { + return new IdMapper(); + } + + + @Test + public void testMapComponentNameToUniqueId() throws Exception { + IdMapper testSubject; + String componentInstanceName = ""; + GraphVertex serviceVertex = null; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); + } + + + @Test + public void testMapUniqueIdToComponentNameTo() throws Exception { + IdMapper testSubject; + String compUniqueId = ""; + GraphVertex serviceVertex = null; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.mapUniqueIdToComponentNameTo(compUniqueId, serviceVertex); + } +} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java new file mode 100644 index 0000000000..740d148a79 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java @@ -0,0 +1,137 @@ +/* + + * Copyright (c) 2018 Huawei Intellectual Property. + + * + + * Licensed under the Apache License, Version 2.0 (the "License"); + + * you may not use this file except in compliance with the License. + + * You may obtain a copy of the License at + + * + + * http://www.apache.org/licenses/LICENSE-2.0 + + * + + * Unless required by applicable law or agreed to in writing, software + + * distributed under the License is distributed on an "AS IS" BASIS, + + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + + * See the License for the specific language governing permissions and + + * limitations under the License. + + */ +package org.openecomp.sdc.be.model.jsonjanusgraph.utils; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; + +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + +@RunWith(MockitoJUnitRunner.class) +public class ModelConverterTest { + @InjectMocks + private ModelConverter test; + + @Test + public void testConvertToToscaElementService() + { + Service service = new Service(); + service.setComponentType(ComponentTypeEnum.SERVICE); + TopologyTemplate template = test.convertToToscaElement(service); + assertThat(template.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE); + } + + @Test + public void testConvertToToscaElementResource() + { + Resource resource = new Resource(); + resource.setComponentType(ComponentTypeEnum.RESOURCE); + NodeType nodeType = test.convertToToscaElement(resource); + assertThat(nodeType.getToscaType()).isEqualTo(ToscaElementTypeEnum.NODE_TYPE); + } + + @Test + public void testConvertFromToscaElementService() + { + TopologyTemplate topologyTemplate = new TopologyTemplate(); + topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); + Component component = test.convertFromToscaElement(topologyTemplate); + assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); + } + + @Test + public void testConvertFromToscaElementServiceWithSelfCapabilities() + { + TopologyTemplate topologyTemplate = new TopologyTemplate(); + + Map capabilitiesProperties = CapabilityTestUtils + .createCapPropsForTopologyTemplate(topologyTemplate); + + topologyTemplate.setCapabilitiesProperties(capabilitiesProperties); + + topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); + Component component = test.convertFromToscaElement(topologyTemplate); + assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); + } + + @Test + public void testConvertFromToscaElementResource() + { + TopologyTemplate topologyTemplate = new TopologyTemplate(); + topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE); + Component component = test.convertFromToscaElement(topologyTemplate); + assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); + } + + @Test + public void testConvertFromToscaElementResourceType() + { + TopologyTemplate topologyTemplate = new TopologyTemplate(); + topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE); + topologyTemplate.setResourceType(ResourceTypeEnum.PNF); + Resource resource = test.convertFromToscaElement(topologyTemplate); + assertSame(ResourceTypeEnum.PNF, resource.getResourceType()); + } + + @Test + public void testIsAtomicComponent() + { + Resource component = new Resource(); + component.setComponentType(ComponentTypeEnum.RESOURCE); + boolean result = test.isAtomicComponent(component); + assertTrue(result); + } + + @Test + public void testGetVertexType() + { + VertexTypeEnum result; + Resource component = new Resource(); + component.setComponentType(ComponentTypeEnum.RESOURCE); + result = test.getVertexType(component); + assertThat(result.getName()).isEqualTo("node_type"); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java deleted file mode 100644 index 493cb74a25..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java +++ /dev/null @@ -1,173 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import java.util.List; -import java.util.Map; - -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; - - -public class NodeTypeTest { - - private NodeType createTestSubject() { - return new NodeType(); - } - - - @Test - public void testGetDerivedList() throws Exception { - NodeType testSubject; - List result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getDerivedList(); - } - - - @Test - public void testSetDerivedList() throws Exception { - NodeType testSubject; - List derivedList = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDerivedList(derivedList); - } - - - @Test - public void testGetDerivedFrom() throws Exception { - NodeType testSubject; - List result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getDerivedFrom(); - } - - - @Test - public void testSetDerivedFrom() throws Exception { - NodeType testSubject; - List derivedFrom = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDerivedFrom(derivedFrom); - } - - - @Test - public void testGetAttributes() throws Exception { - NodeType testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getAttributes(); - } - - - @Test - public void testSetAttributes() throws Exception { - NodeType testSubject; - Map attributes = null; - - // default test - testSubject = createTestSubject(); - testSubject.setAttributes(attributes); - } - - - @Test - public void testGetCapabilties() throws Exception { - NodeType testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCapabilities(); - } - - - @Test - public void testSetCapabilties() throws Exception { - NodeType testSubject; - Map capabilties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCapabilities(capabilties); - } - - - @Test - public void testGetRequirements() throws Exception { - NodeType testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getRequirements(); - } - - - @Test - public void testSetRequirements() throws Exception { - NodeType testSubject; - Map requirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setRequirements(requirements); - } - - - @Test - public void testGetCapabiltiesProperties() throws Exception { - NodeType testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCapabilitiesProperties(); - } - - - @Test - public void testSetCapabiltiesProperties() throws Exception { - NodeType testSubject; - Map capabiltiesProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCapabilitiesProperties(capabiltiesProperties); - } - - - @Test - public void testGetInterfaceArtifacts() throws Exception { - NodeType testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInterfaceArtifacts(); - } - - - @Test - public void testSetInterfaceArtifacts() throws Exception { - NodeType testSubject; - Map interfaceArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInterfaceArtifacts(interfaceArtifacts); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java deleted file mode 100644 index c13ddd3970..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java +++ /dev/null @@ -1,423 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import java.util.Map; - -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.DataTypeDefinition; - - -public class TopologyTemplateTest { - - private TopologyTemplate createTestSubject() { - return new TopologyTemplate(); - } - - - @Test - public void testGetInputs() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInputs(); - } - - - @Test - public void testSetInputs() throws Exception { - TopologyTemplate testSubject; - Map inputs = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInputs(inputs); - } - - - @Test - public void testGetInstInputs() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstInputs(); - } - - - @Test - public void testSetInstInputs() throws Exception { - TopologyTemplate testSubject; - Map instInputs = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstInputs(instInputs); - } - - - @Test - public void testGetHeatParameters() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getHeatParameters(); - } - - - @Test - public void testSetHeatParameters() throws Exception { - TopologyTemplate testSubject; - Map heatParameters = null; - - // default test - testSubject = createTestSubject(); - testSubject.setHeatParameters(heatParameters); - } - - - @Test - public void testGetInstAttributes() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstAttributes(); - } - - - @Test - public void testSetInstAttributes() throws Exception { - TopologyTemplate testSubject; - Map instAttributes = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstAttributes(instAttributes); - } - - - @Test - public void testGetInstProperties() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstProperties(); - } - - - @Test - public void testSetInstProperties() throws Exception { - TopologyTemplate testSubject; - Map instProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstProperties(instProperties); - } - - - @Test - public void testGetGroups() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getGroups(); - } - - - @Test - public void testSetGroups() throws Exception { - TopologyTemplate testSubject; - Map groups = null; - - // default test - testSubject = createTestSubject(); - testSubject.setGroups(groups); - } - - - @Test - public void testGetInstGroups() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstGroups(); - } - - - @Test - public void testSetInstGroups() throws Exception { - TopologyTemplate testSubject; - Map instGroups = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstGroups(instGroups); - } - - - @Test - public void testGetServiceApiArtifacts() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getServiceApiArtifacts(); - } - - - @Test - public void testSetServiceApiArtifacts() throws Exception { - TopologyTemplate testSubject; - Map serviceApiArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setServiceApiArtifacts(serviceApiArtifacts); - } - - - @Test - public void testGetCompositions() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCompositions(); - } - - - @Test - public void testSetCompositions() throws Exception { - TopologyTemplate testSubject; - Map compositions = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCompositions(compositions); - } - - - @Test - public void testGetCalculatedCapabilities() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedCapabilities(); - } - - - @Test - public void testSetCalculatedCapabilities() throws Exception { - TopologyTemplate testSubject; - Map calculatedCapabilities = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedCapabilities(calculatedCapabilities); - } - - - @Test - public void testGetCalculatedRequirements() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedRequirements(); - } - - - @Test - public void testSetCalculatedRequirements() throws Exception { - TopologyTemplate testSubject; - Map calculatedRequirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedRequirements(calculatedRequirements); - } - - - @Test - public void testGetFullfilledCapabilities() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getFullfilledCapabilities(); - } - - - @Test - public void testSetFullfilledCapabilities() throws Exception { - TopologyTemplate testSubject; - Map fullfilledCapabilities = null; - - // default test - testSubject = createTestSubject(); - testSubject.setFullfilledCapabilities(fullfilledCapabilities); - } - - - @Test - public void testGetFullfilledRequirements() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getFullfilledRequirements(); - } - - - @Test - public void testSetFullfilledRequirements() throws Exception { - TopologyTemplate testSubject; - Map fullfilledRequirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setFullfilledRequirements(fullfilledRequirements); - } - - - @Test - public void testGetInstDeploymentArtifacts() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstDeploymentArtifacts(); - } - - - @Test - public void testSetInstDeploymentArtifacts() throws Exception { - TopologyTemplate testSubject; - Map instDeploymentArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstDeploymentArtifacts(instDeploymentArtifacts); - } - - - @Test - public void testGetCalculatedCapabilitiesProperties() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedCapabilitiesProperties(); - } - - - @Test - public void testSetCalculatedCapabilitiesProperties() throws Exception { - TopologyTemplate testSubject; - Map calculatedCapabilitiesProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedCapabilitiesProperties(calculatedCapabilitiesProperties); - } - - - @Test - public void testGetInstanceArtifacts() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstanceArtifacts(); - } - - - @Test - public void testSetInstanceArtifacts() throws Exception { - TopologyTemplate testSubject; - Map instanceArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstanceArtifacts(instanceArtifacts); - } - - - @Test - public void testGetDataTypes() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getDataTypes(); - } - - - @Test - public void testSetDataTypes() throws Exception { - TopologyTemplate testSubject; - Map dataTypes = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDataTypes(dataTypes); - } - - - @Test - public void testGetComponentInstances() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getComponentInstances(); - } - - - @Test - public void testSetComponentInstances() throws Exception { - TopologyTemplate testSubject; - Map instances = null; - - // default test - testSubject = createTestSubject(); - testSubject.setComponentInstances(instances); - } - - - @Test - public void testGetRelations() throws Exception { - TopologyTemplate testSubject; - Map result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getRelations(); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java deleted file mode 100644 index 918b0328a9..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.junit.Test; - - -public class ToscaElementTypeEnumTest { - - private ToscaElementTypeEnum createTestSubject() { - return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE; - } - - - - - - @Test - public void testGetValue() throws Exception { - ToscaElementTypeEnum testSubject; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getValue(); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java deleted file mode 100644 index b00b13e162..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.enums; - -import org.junit.Test; - - -public class JsonConstantKeysEnumTest { - - private JsonConstantKeysEnum createTestSubject() { - return JsonConstantKeysEnum.COMPOSITION; - } - - - @Test - public void testGetValue() throws Exception { - JsonConstantKeysEnum testSubject; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getValue(); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java deleted file mode 100644 index b906604037..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java +++ /dev/null @@ -1,486 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import javax.annotation.Resource; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * Created by yavivi on 21/03/2018. - */ -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(value = {"classpath:application-context-test.xml", "classpath:healing-context-test.xml"}) -public class ArchiveOperationTest extends ModelTestBase { - - private static final String CI_UID_RES1_CP = "cp_uid"; - private static final String CI_UID_RES2_VL = "vl_uid"; - private static final String CI_UID_SVC_PROXY = "svc_proxy_uid"; - - @Resource - private ArchiveOperation archiveOperation; - - @Resource - private TitanDao titanDao; - - private boolean isInitialized; - - private GraphVertex serviceVertex1; - private GraphVertex archivedVertex1; - - GraphVertex archiveVertex; - GraphVertex catalogVertex; - - private GraphVertex serviceVertex1_0; - private GraphVertex serviceVertex1_1; - private GraphVertex serviceVertex2_0; - private GraphVertex serviceVertex3_0; - private GraphVertex serviceVertex3_1; - - private GraphVertex serviceVertex0_1; - private GraphVertex serviceVertex0_2; - private GraphVertex serviceVertex0_3; - private GraphVertex serviceVertex0_4; - private GraphVertex serviceVertex0_5; - - //Composition Elements - private GraphVertex compositionService; - private GraphVertex compositionResource1; - private GraphVertex compositionResource2; - private GraphVertex compositionServiceProxy; - private GraphVertex compositionAnotherService; - - //For VSP Archive Notification - private GraphVertex vfResource0_1; - private GraphVertex vfResource0_2; - private GraphVertex vfResource1_0; - private String csarUuid = "123456789";; - - @BeforeClass - public static void initTest(){ - ModelTestBase.init(); - } - - @Before - public void beforeTest() { - if (!isInitialized) { - GraphTestUtils.clearGraph(titanDao); - initGraphForTest(); - isInitialized = true; - } - } - - @Test - public void testArchiveComponentSingleVersion(){ - String componentId = serviceVertex1.getUniqueId(); - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); - assertThat(actionStatus.isLeft()).isTrue(); - assertArchived(serviceVertex1.getUniqueId()); - } - - @Test - public void testArchiveComponentFailsWhenInCheckoutSingleVersion(){ - checkoutComponent(serviceVertex1); - String componentId = serviceVertex1.getUniqueId(); - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); - assertThat(actionStatus.isLeft()).isFalse(); - assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); - } - - @Test - public void testArchiveWithWrongId() { - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent("fakeComponentId"); - assertThat(actionStatus.isLeft()).isFalse(); - assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); - } - - @Test - public void testAlreadyArchived() { - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(archivedVertex1.getUniqueId()); - assertThat(actionStatus.isLeft()).isTrue(); - assertThat(actionStatus.left().value()).containsExactly(archivedVertex1.getUniqueId()); - } - - @Test - public void testScenario2_archive_1_0(){ - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_0.getUniqueId()); - assertThat(actionStatus.isLeft()).isTrue(); - assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); - assertArchived(serviceVertex1_0.getUniqueId()); - assertArchived(serviceVertex1_1.getUniqueId()); - } - - @Test - public void testScenario2_archive_1_1(){ - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_1.getUniqueId()); - assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); - assertArchived(serviceVertex1_0.getUniqueId()); - assertArchived(serviceVertex1_1.getUniqueId()); - } - - @Test - public void testScenario4_oneLowOneHighestVersion(){ - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); - assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); - assertArchived(serviceVertex0_1.getUniqueId()); - assertArchived(serviceVertex0_2.getUniqueId()); - assertArchived(serviceVertex0_3.getUniqueId()); - assertArchived(serviceVertex0_4.getUniqueId()); - assertArchived(serviceVertex0_5.getUniqueId()); - - actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_2.getUniqueId()); - assertThat(actionStatus.isLeft()).isTrue(); - assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); - } - - - /////////////// Continue Here ////////////////// - @Test - public void testScenario4_archiveFromNonHighest(){ - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); - assertArchived(serviceVertex0_1.getUniqueId()); - assertArchived(serviceVertex0_2.getUniqueId()); - assertArchived(serviceVertex0_3.getUniqueId()); - assertArchived(serviceVertex0_4.getUniqueId()); - assertArchived(serviceVertex0_5.getUniqueId()); - - actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_3.getUniqueId()); - assertRestored(serviceVertex0_1.getUniqueId()); - assertRestored(serviceVertex0_2.getUniqueId()); - assertRestored(serviceVertex0_3.getUniqueId()); - assertRestored(serviceVertex0_4.getUniqueId()); - assertRestored(serviceVertex0_5.getUniqueId()); - } - - @Test - public void testArchiveFailsWhenHighestVersionIsInCheckoutState(){ - checkoutComponent(serviceVertex0_5); - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); - assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); - } - - @Test - public void testScenario3_archive_3_0(){ - Either, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex3_0.getUniqueId()); - assertArchived(serviceVertex3_0.getUniqueId()); - assertArchived(serviceVertex3_1.getUniqueId()); - assertArchivedProps(serviceVertex2_0.getUniqueId()); - } - - @Test - public void testArchivedOriginsCalculation(){ - - //Archive the CP resource - this.archiveOperation.archiveComponent(this.compositionResource1.getUniqueId()); - this.archiveOperation.archiveComponent(this.compositionServiceProxy.getUniqueId()); - - List ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); - - //Validate that method returns the CI of CP - assertThat(ciWithArchivedOrigins).containsExactlyInAnyOrder(CI_UID_RES1_CP, CI_UID_SVC_PROXY); - - Map compositionsJson = (Map) this.compositionService.getJson(); - - assertThat(compositionsJson).isNotNull(); - assertThat(compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue())).isNotNull(); - - CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue()); - - //Get all component instances from composition - Map componentInstances = composition.getComponentInstances(); - for (ComponentInstanceDataDefinition ci : componentInstances.values()) { - //Verify that exactly 2 CIs are marked as archived - if (ci.getUniqueId().equals(CI_UID_RES1_CP) || ci.getUniqueId().equals(CI_UID_SVC_PROXY)) { - assertThat(ci.isOriginArchived()).isTrue(); - } - } - - } - - @Test - public void testNoArchivedOriginsCalculation(){ - List ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); - - //Validate that method returns the CI of CP - assertThat(ciWithArchivedOrigins).isEmpty(); - } - - @Test - public void testOnVspArchivedAndRestored(){ - this.archiveOperation.onVspArchived(csarUuid); - //assertOnCommit(); - - assertOnVspArchived(true); - - this.archiveOperation.onVspRestored(csarUuid); - //assertOnCommit(); - assertOnVspArchived(false); - - //Not Found CSAR UUID - ActionStatus result = this.archiveOperation.onVspRestored("fakeUuid"); - //assertOnCommit(); - assertThat(result).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); - } - - private void assertOnVspArchived(boolean expectedValue) { - GraphVertex v = titanDao.getVertexById(vfResource0_1.getUniqueId()).left().value(); - assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); - - v = titanDao.getVertexById(vfResource0_2.getUniqueId()).left().value(); - assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); - - v = titanDao.getVertexById(vfResource1_0.getUniqueId()).left().value(); - assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); - } - - /************************** - * Utility Methods - *************************/ - - private void checkoutComponent(GraphVertex serviceVertex0_5) { - Either vE = titanDao.getVertexById(serviceVertex0_5.getUniqueId()); - GraphVertex v = vE.left().value(); - v.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - v.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - titanDao.updateVertex(v); - assertOnCommit(); - } - - private void assertOnCommit(){ - final TitanOperationStatus commit = this.titanDao.commit(); - assertThat(commit).isEqualTo(TitanOperationStatus.OK); - } - - private void assertArchived(String componentUniqueId) { - assertArchivedOrRestored(ArchiveOperation.Action.ARCHIVE, componentUniqueId); - } - - private void assertRestored(String componentUniqueId) { - assertArchivedOrRestored(ArchiveOperation.Action.RESTORE, componentUniqueId); - } - - private void assertArchivedOrRestored(ArchiveOperation.Action action, String componentUniqueId) { - GraphVertex v = titanDao.getVertexById(componentUniqueId).left().value(); - - EdgeLabelEnum requiredEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.ARCHIVE_ELEMENT : EdgeLabelEnum.CATALOG_ELEMENT; - EdgeLabelEnum otherEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.CATALOG_ELEMENT : EdgeLabelEnum.ARCHIVE_ELEMENT; - - GraphVertex parent = null; - Either otherLookup = null; - Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); - if (isHighest != null && isHighest) { - //Highest version are linked to Archive/Catalog Root - parent = titanDao.getParentVertex(v, requiredEdge, JsonParseFlagEnum.NoParse).left().value(); - otherLookup = titanDao.getParentVertex(v, otherEdge, JsonParseFlagEnum.NoParse); - assertThat(otherLookup.isRight()).isTrue(); //Verify that component is not linked to Catalog/Archive Root - assertThat(parent.getUniqueId()).isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? this.archiveVertex.getUniqueId() : this.catalogVertex.getUniqueId()); //Verify that parent is indeed Archive Root - } - - assertArchivedOrRestoredProps(action, v); - } - - private void assertArchivedProps(String uniqueId) { - GraphVertex v = - titanDao.getVertexById(uniqueId).left().value(); - assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v); - } - - private void assertRestoredProps(String uniqueId) { - GraphVertex v = - titanDao.getVertexById(uniqueId).left().value(); - assertArchivedOrRestoredProps(ArchiveOperation.Action.RESTORE, v); - } - - private void assertArchivedOrRestoredProps(ArchiveOperation.Action action, GraphVertex v) { - Object isArchived = v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); - Object archiveTime = v.getMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME); - assertThat(isArchived).isNotNull().isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? true : false); - assertThat(archiveTime).isNotNull(); - } - - /******************************* - * Preperation Methods - *******************************/ - private void initGraphForTest() { - //Create Catalog Root - this.catalogVertex = GraphTestUtils.createRootCatalogVertex(titanDao); - //Create Archive Root - this.archiveVertex = GraphTestUtils.createRootArchiveVertex(titanDao); - - createScenario1_SingleVersionNode(); - createScenario2_TwoHighestVersions(); - createScenario3_TwoHighestVersionsOneLowest(); - createMiscServices(); - createServiceCompositionForCalculatingArchivedOrigins(); - createScenario4_1Highest4LowestVersions(); - createResourcesForArchivedVsp(); - - assertOnCommit(); - } - - private void createScenario1_SingleVersionNode() { - //Create Service for Scenario 1 Tests (1 Service) - this.serviceVertex1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - - //Connect Service to Catalog Root - titanDao.createEdge(catalogVertex, serviceVertex1, EdgeLabelEnum.CATALOG_ELEMENT, null); - } - - private void createScenario2_TwoHighestVersions() { - //Create Service for Scenario 2 Tests (1 Service) - this.serviceVertex1_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - - titanDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null); - - //Connect 1.0 and 1.1 to Catalog Root - titanDao.createEdge(catalogVertex, serviceVertex1_0, EdgeLabelEnum.CATALOG_ELEMENT, null); - titanDao.createEdge(catalogVertex, serviceVertex1_1, EdgeLabelEnum.CATALOG_ELEMENT, null); - } - - private void createScenario3_TwoHighestVersionsOneLowest() { - //Create Service for Scenario 1 Tests (1 Service) - this.serviceVertex2_0 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); //NonHighestVersion - this.serviceVertex3_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - this.serviceVertex3_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - - //Connect version edges - titanDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null); - titanDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null); - - //Connect 3.0 and 3.1 to Catalog Root - titanDao.createEdge(catalogVertex, serviceVertex3_0, EdgeLabelEnum.CATALOG_ELEMENT, null); - titanDao.createEdge(catalogVertex, serviceVertex3_1, EdgeLabelEnum.CATALOG_ELEMENT, null); - } - - private void createScenario4_1Highest4LowestVersions() { - //2 Lowest version only - this.serviceVertex0_1 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); - this.serviceVertex0_2 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); - this.serviceVertex0_3 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); - this.serviceVertex0_4 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); - this.serviceVertex0_5 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - - titanDao.createEdge(serviceVertex0_1, serviceVertex0_2, EdgeLabelEnum.VERSION, null); - titanDao.createEdge(serviceVertex0_2, serviceVertex0_3, EdgeLabelEnum.VERSION, null); - titanDao.createEdge(serviceVertex0_3, serviceVertex0_4, EdgeLabelEnum.VERSION, null); - titanDao.createEdge(serviceVertex0_4, serviceVertex0_5, EdgeLabelEnum.VERSION, null); - - titanDao.createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null); - } - - private void createResourcesForArchivedVsp(){ - Map vfPropsNonHighest = propsForNonHighestVersion(); - Map vfPropsHighest = propsForNonHighestVersion(); - - vfPropsNonHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); - vfPropsNonHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); - vfPropsHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); - vfPropsHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); - - this.vfResource0_1 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF); - this.vfResource0_2 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF); - this.vfResource1_0 = GraphTestUtils.createResourceVertex(titanDao, vfPropsHighest, ResourceTypeEnum.VF); - - titanDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null); - titanDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null); - } - - private void createMiscServices() { - //Create Service for Scenario 1 Tests (1 Service) - this.archivedVertex1 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); - - //Connect Service to Catalog Root - titanDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null); - } - - private void createServiceCompositionForCalculatingArchivedOrigins(){ - //Service that point to another service in composition - this.compositionService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - this.compositionAnotherService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); - - this.compositionResource1 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.CP); - this.compositionResource2 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.VL); - this.compositionServiceProxy = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.ServiceProxy); - - titanDao.createEdge(compositionService, compositionResource1, EdgeLabelEnum.INSTANCE_OF, null); - titanDao.createEdge(compositionService, compositionResource2, EdgeLabelEnum.INSTANCE_OF, null); - titanDao.createEdge(compositionService, compositionServiceProxy, EdgeLabelEnum.INSTANCE_OF, null); - titanDao.createEdge(compositionService, compositionAnotherService, EdgeLabelEnum.PROXY_OF, null); - - createAndAttachCompositionJson(compositionService); - } - - private void createAndAttachCompositionJson(GraphVertex compositionService) { - //Full composition json - Map compositions = new HashMap<>(); - //Single composition data - CompositionDataDefinition composition = new CompositionDataDefinition(); - //Instances Map - Map instances = new HashMap<>(); - - //Prepare Instances Map - ComponentInstanceDataDefinition instance = new ComponentInstanceDataDefinition(); - instance.setUniqueId(CI_UID_RES1_CP); - instance.setComponentUid(compositionResource1.getUniqueId()); - instances.put(CI_UID_RES1_CP, instance); - - instance = new ComponentInstanceDataDefinition(); - instance.setUniqueId(CI_UID_RES2_VL); - instance.setComponentUid(compositionResource2.getUniqueId()); - instances.put(CI_UID_RES2_VL, instance); - - instance = new ComponentInstanceDataDefinition(); - instance.setUniqueId(CI_UID_SVC_PROXY); - instance.setComponentUid(compositionServiceProxy.getUniqueId()); - instances.put(CI_UID_SVC_PROXY, instance); - - //Add Instances to Composition - composition.setComponentInstances(instances); - //Add to full composition - compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition); - //Add Full Json to vertex - compositionService.setJson(compositions); - //System.out.println(JsonParserUtils.toJson(compositions)); - titanDao.updateVertex(compositionService); - } - - private Map propsForHighestVersion(){ - Map props = new HashMap(); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - return props; - } - - private Map propsForNonHighestVersion(){ - Map props = new HashMap(); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - return props; - } - -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java deleted file mode 100644 index 410cef9ae8..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java +++ /dev/null @@ -1,83 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Test; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; - -public class ArtifactsOperationsTest { - - private static final String SERVICE_ID = "serviceId"; - private static final String INSTANCE_ID = "instanceId"; - private ArtifactsOperations testInstance = mock(ArtifactsOperations.class, CALLS_REAL_METHODS); - - @Test - public void getInstanceArtifacts_collectAllInstanceArtifacts() throws Exception { - Map instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); - - Map instanceDeploymentArtifacts = new HashMap<>(); - instanceDeploymentArtifacts.put(INSTANCE_ID, getArtifactsByInstance("name2", "name3")); - instanceDeploymentArtifacts.put("instanceId2", getArtifactsByInstance("name4")); - - doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); - doReturn(Either.left(instanceDeploymentArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); - - assertTrue(allInstArtifacts.isLeft()); - assertEquals(allInstArtifacts.left().value().size(), 3); - assertTrue(allInstArtifacts.left().value().containsKey("name1")); - assertTrue(allInstArtifacts.left().value().containsKey("name2")); - assertTrue(allInstArtifacts.left().value().containsKey("name3")); - assertFalse(allInstArtifacts.left().value().containsKey("name4"));//this key is of different instance - } - - @Test - public void getInstanceArtifacts_noArtifactsForInstance() throws Exception { - Map instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); - - doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); - doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, "someOtherInstance"); - - assertTrue(allInstArtifacts.isLeft()); - assertTrue(allInstArtifacts.left().value().isEmpty()); - } - - @Test - public void getInstanceArtifacts_errorGettingInstanceArtifacts() throws Exception { - doReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); - Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); - verify(testInstance, times(0)).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - assertTrue(allInstArtifacts.isRight()); - } - - @Test - public void getAllInstanceArtifacts_errorGettingDeploymentArtifacts() throws Exception { - doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); - doReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); - Either, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); - assertTrue(allInstArtifacts.isRight()); - } - - private ToscaDataDefinition getArtifactsByInstance(String ... artifactsNames) { - MapArtifactDataDefinition artifactsByInstance = new MapArtifactDataDefinition(); - Map artifactsByName = new HashMap<>(); - for (String artifactName : artifactsNames) { - artifactsByName.put(artifactName, new ArtifactDataDefinition()); - } - artifactsByInstance.setMapToscaDataDefinition(artifactsByName); - return artifactsByInstance; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperationTest.java deleted file mode 100644 index 0c9c35b62a..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/CapabilitiesOperationTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.utils.CapabilityTestUtils; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; - -import java.util.HashMap; -import java.util.Map; - -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyMap; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.when; - -public class CapabilitiesOperationTest { - - @InjectMocks - CapabilitiesOperation operation = new CapabilitiesOperation(); - @Mock - private TitanDao mockTitanDao; - @Mock - private TopologyTemplateOperation topologyTemplateOperation; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - - when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK); - when(mockTitanDao.getVertexById(anyString(), any())).thenReturn(Either.left(new GraphVertex())); - - when(topologyTemplateOperation.updateFullToscaData(any(), any(), any(), anyMap())).thenReturn(StorageOperationStatus.OK); - TopologyTemplate topologyTemplate = new TopologyTemplate(); - - Map capPropsForTopologyTemplate = CapabilityTestUtils - .createCapPropsForTopologyTemplate(topologyTemplate); - topologyTemplate.setCapabilitiesProperties(capPropsForTopologyTemplate); - - when(topologyTemplateOperation.getToscaElement(anyString(), any())).thenReturn(Either.left(topologyTemplate)); - } - - @Test - public void testCreateOrUpdateCapabilitiesProperties() { - - Map mapToscaDataDefinition = new HashMap<>(); - PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(); - propertyDataDefinition.setUniqueId("ComponentInput1_uniqueId"); - propertyDataDefinition.setName("propName"); - mapToscaDataDefinition.put(propertyDataDefinition.getUniqueId(), propertyDataDefinition); - MapPropertiesDataDefinition mapPropertiesDataDefinition = new MapPropertiesDataDefinition(mapToscaDataDefinition); - - Map propertiesMap = new HashMap<>(); - propertiesMap.put(propertyDataDefinition.getUniqueId(), mapPropertiesDataDefinition); - - StorageOperationStatus operationStatus = operation.createOrUpdateCapabilityProperties("componentId", - propertiesMap); - - Assert.assertEquals(StorageOperationStatus.OK, operationStatus); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java deleted file mode 100644 index e580fd51bb..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java +++ /dev/null @@ -1,226 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mockito; -import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; -import org.openecomp.sdc.be.model.jsontitan.utils.IdMapper; -import org.openecomp.sdc.be.model.operations.StorageException; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import javax.annotation.Resource; -import java.util.*; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.when; - -/** - * Created by yavivi on 26/01/2018. - */ -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration("classpath:application-context-test.xml") -public class ExternalReferencesOperationTest extends ModelTestBase { - - private static final String COMPONENT_ID = "ci-MyComponentName"; - private static final String COMPONENT2_ID = "ci-MyComponentName2"; - private static final String MONITORING_OBJECT_TYPE = "monitoring"; - private static final String WORKFLOW_OBJECT_TYPE = "workflow"; - private static final String REF_1 = "ref1"; - private static final String REF_2 = "ref2"; - private static final String REF_3 = "ref3"; - private static final String REF_4 = "ref4"; - private static final String REF_5 = "ref5"; - //workflow - private static final String REF_6 = "ref6"; - - @Resource - private ExternalReferencesOperation externalReferenceOperation; - - @Resource - private TitanDao titanDao; - - private boolean isInitialized; - - private GraphVertex serviceVertex; - private GraphVertex serviceVertex2; - private GraphVertex serviceVertex3; - - private String serviceVertexUuid; - private String serviceVertex2Uuid; - private String serviceVertex3Uuid; - - private IdMapper idMapper; - - @BeforeClass - public static void initTest(){ - ModelTestBase.init(); - } - - @Before - public void beforeTest() { - idMapper = Mockito.mock(IdMapper.class); - this.externalReferenceOperation.setIdMapper(idMapper); - when(idMapper.mapComponentNameToUniqueId(Mockito.anyString(), Mockito.any(GraphVertex.class))).thenReturn(COMPONENT_ID); - if (!isInitialized) { - GraphTestUtils.clearGraph(titanDao); - initGraphForTest(); - isInitialized = true; - } - } - - @Test - public void testAddComponentInstanceExternalRef(){ - Either addResult = externalReferenceOperation.addExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_4); - assertThat(addResult.isLeft()).isEqualTo(true); - - //commit changes to titan - final TitanOperationStatus commit = this.titanDao.commit(); - assertThat(commit).isEqualTo(TitanOperationStatus.OK); - - assertThat(getServiceExternalRefs()).contains(REF_1, REF_2, REF_3, REF_4); - } - - @Test - public void testAddExternalReferences_success() { - Map> refsMap = Collections.singletonMap(MONITORING_OBJECT_TYPE, Arrays.asList(REF_1, REF_2)); - externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID, refsMap); - Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID); - assertThat(allExternalReferences.size()).isEqualTo(1); - assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); - externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID, refsMap); - Map> allExternalReferences2 = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID); - assertThat(allExternalReferences2.size()).isEqualTo(1); - assertThat(allExternalReferences2).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); - } - - @Test - public void testGetAllCIExternalRefs_success() { - Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertexUuid, COMPONENT_ID); - assertThat(allExternalReferences.size()).isEqualTo(2); - assertThat(allExternalReferences).flatExtracting(WORKFLOW_OBJECT_TYPE).containsExactly(REF_6); - assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2, REF_3, REF_5); - } - - @Test - public void testGetAllCIExternalRefs_noRefsExist() { - Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, COMPONENT_ID); - assertThat(allExternalReferences.size()).isZero(); - } - - @Test - public void testGetAllCIExternalRefs_noSuchComponentInstance() { - Map> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, "FAKE"); - assertThat(allExternalReferences.size()).isZero(); - } - - @Test(expected=StorageException.class) - public void testGetAllCIExternalRefs_nonExitingService_throwsException() { - externalReferenceOperation.getAllExternalReferences("FAKE", COMPONENT_ID); - } - - @Test - public void testGetComponentInstanceExternalRef(){ - assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); - assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE).left().value()).containsExactly(REF_6); - } - - @Test - public void testGetComponentInstanceExternalRefForNonExistingObjectId(){ - assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); - Either, ActionStatus> getResult = externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, "FAKE_OBJECT_TYPE"); - assertThat(getResult.left().value()).isEmpty(); - } - - @Test - public void testDeleteComponentInstanceExternalRef(){ - //Test the precondition - assertThat(getServiceExternalRefs()).contains(REF_5); - - //Remove REF 5 - Either deleteStatus = externalReferenceOperation.deleteExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); - assertThat(deleteStatus.isLeft()).isEqualTo(true); - - //commit changes to titan - final TitanOperationStatus commit = this.titanDao.commit(); - assertThat(commit).isEqualTo(TitanOperationStatus.OK); - - //Check that ref does not exist anymore - assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3); - } - - @Test - public void testUpdateComponentInstanceExternalRef(){ - //Test the precondition - assertThat(getServiceExternalRefs()).contains(REF_5).doesNotContain(REF_4); - - //Update REF 5 with REF_4 - Either updateResult = externalReferenceOperation.updateExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5, REF_4); - - assertThat(updateResult.isLeft()).isEqualTo(true); - - //commit changes to titan - final TitanOperationStatus commit = this.titanDao.commit(); - assertThat(commit).isEqualTo(TitanOperationStatus.OK); - - //Check that ref does not exist anymore - assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3, REF_4); - } - - private List getServiceExternalRefs(){ - //Get service vertex - final Either externalRefsVertexResult = this.titanDao.getChildVertex(this.serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, JsonParseFlagEnum.ParseJson); - assertThat(externalRefsVertexResult.isLeft()).isEqualTo(true); - - GraphVertex externalRefVertex = externalRefsVertexResult.left().value(); - - //Get the full map - Map componentInstancesMap = (Map) externalRefVertex.getJson(); - assertThat(componentInstancesMap).isNotNull(); - - //Get Map of external refs by object type - final MapComponentInstanceExternalRefs mapComponentInstanceExternalRefs = componentInstancesMap.get(COMPONENT_ID); - - //Get List of references - //final List externalRefsByObjectType = mapComponentInstanceExternalRefs.externalRefsByObjectType(objectType); - - return mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE); - } - - private void initGraphForTest() { - //create a service - this.serviceVertex = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); - this.serviceVertexUuid = this.serviceVertex.getUniqueId(); - - //monitoring references - externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_1); - externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_2); - externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_3); - externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); - - //workflow references - externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE, REF_6); - - //create a service without refs - serviceVertex2 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); - serviceVertex2Uuid = serviceVertex2.getUniqueId(); - - //create a service for adding all references - serviceVertex3 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); - serviceVertex3Uuid = serviceVertex3.getUniqueId(); - - final TitanOperationStatus commit = this.titanDao.commit(); - assertThat(commit).isEqualTo(TitanOperationStatus.OK); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java deleted file mode 100644 index 575fbbca59..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java +++ /dev/null @@ -1,105 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import static java.util.Arrays.asList; -import static org.assertj.core.api.Assertions.assertThat; - -import fj.data.Either; -import java.util.List; -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.config.TitanSpringConfig; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.GroupDefinition; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) -public class GroupsOperationTest extends ModelTestBase { - - @Autowired - private GroupsOperation groupsOperation; - - @Autowired - HealingTitanDao titanDao; - - @Autowired - private ToscaOperationFacade toscaOperationFacade; - private Component container; - - @BeforeClass - public static void initClass() { - ModelTestBase.init(); - } - - @Before - public void setUp() throws Exception { - container = new Resource(); - container.setUniqueId(CONTAINER_ID); - Either createdCmpt = titanDao.createVertex(createBasicContainerGraphVertex()); - assertThat(createdCmpt.isLeft()).isTrue(); - - } - - @After - public void tearDown() throws Exception { - titanDao.rollback(); - } - - @Test - public void addGroups_whenContainerHasNoGroups_associateContainerWithGroup() { - GroupDefinition g1 = createGroupDefinition("g1"); - GroupDefinition g2 = createGroupDefinition("g2"); - Either, StorageOperationStatus> createGroups = groupsOperation.addGroups(container, asList(g1, g2)); - assertThat(createGroups.isLeft()).isTrue(); - - ComponentParametersView getGroupsFilter = new ComponentParametersView(true); - getGroupsFilter.setIgnoreGroups(false); - Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); - assertThat(cmptWithGroups.getGroups()) - .usingElementComparatorOnFields("name", "uniqueId") - .containsExactlyInAnyOrder(g1, g2); - } - - @Test - public void addGroups_whenContainerHasGroups_addTheGivenGroupsToTheGroupsList() { - GroupDefinition g1 = createGroupDefinition("g1"); - GroupDefinition g2 = createGroupDefinition("g2"); - groupsOperation.addGroups(container, asList(g1, g2)).left().value(); - - GroupDefinition g3 = createGroupDefinition("g3"); - GroupDefinition g4 = createGroupDefinition("g4"); - - groupsOperation.addGroups(container, asList(g3, g4)).left().value(); - - ComponentParametersView getGroupsFilter = new ComponentParametersView(true); - getGroupsFilter.setIgnoreGroups(false); - Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); - assertThat(cmptWithGroups.getGroups()) - .usingElementComparatorOnFields("name", "uniqueId") - .containsExactlyInAnyOrder(g1, g2, g3, g4); - - } - - private GroupDefinition createGroupDefinition(String id) { - GroupDefinition groupDefinition = new GroupDefinition(); - groupDefinition.setUniqueId(id); - groupDefinition.setName("name" + id); - return groupDefinition; - } - - -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperationTest.java deleted file mode 100644 index fe2ea209f9..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfaceOperationTest.java +++ /dev/null @@ -1,497 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; - -import fj.data.Either; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import javax.annotation.Resource; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.InterfaceDefinition; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.Operation; -import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; -import org.openecomp.sdc.common.util.ValidationUtils; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration("classpath:application-context-test.xml") -public class InterfaceOperationTest extends ModelTestBase { - - private static final String RESOURCE_NAME = "Resource Name"; - private static final String RESOURCE_ID = "resourceID"; - private static final String SERVICE_NAME = "Service Name"; - private static final String SERVICE_ID = "serviceID"; - private final String categoryName = "category"; - private final String subcategory = "mycategory"; - private final Service service = createService(); - private final org.openecomp.sdc.be.model.Resource resource = createResource(); - @Resource - protected TitanDao titanDao; - @Resource - protected NodeTypeOperation nodeTypeOperation; - @Resource - protected TopologyTemplateOperation topologyTemplateOperation; - @Resource - private InterfaceOperation interfaceOperation; - @Resource - private ToscaElementLifecycleOperation lifecycleOperation; - private GraphVertex ownerVertex; - - @BeforeClass - public static void initInterfacesOperation() { - init(); - } - - @Before - public void setupBefore() { - GraphTestUtils.clearGraph(titanDao); - createUsers(); - createResourceCategory(); - createServiceCategory(); - GraphTestUtils.createRootCatalogVertex(titanDao); - createRootNodeType(); - createNodeType("resource", RESOURCE_ID); - createNodeType("service", SERVICE_ID); - createTopologyTemplate("firstService"); - } - - private void createUsers() { - GraphVertex ownerV = new GraphVertex(VertexTypeEnum.USER); - ownerV.setUniqueId("user1"); - - Map metadataProperties = new HashMap<>(); - metadataProperties.put(GraphPropertyEnum.USERID, ownerV.getUniqueId()); - metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); - metadataProperties.put(GraphPropertyEnum.NAME, "user1"); - ownerV.setMetadataProperties(metadataProperties); - ownerV.updateMetadataJsonWithCurrentMetadataProperties(); - ownerV.setJson(new HashMap<>()); - Either createUserRes = titanDao.createVertex(ownerV); - - ownerVertex = createUserRes.left().value(); - - GraphVertex modifierV = new GraphVertex(VertexTypeEnum.USER); - modifierV.setUniqueId("user2"); - - metadataProperties = new HashMap<>(); - metadataProperties.put(GraphPropertyEnum.USERID, modifierV.getUniqueId()); - metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); - metadataProperties.put(GraphPropertyEnum.NAME, "user2"); - modifierV.setMetadataProperties(metadataProperties); - modifierV.updateMetadataJsonWithCurrentMetadataProperties(); - modifierV.setJson(new HashMap<>()); - createUserRes = titanDao.createVertex(modifierV); - createUserRes.left().value(); - - lifecycleOperation.findUser(ownerVertex.getUniqueId()); - } - - private void createResourceCategory() { - GraphVertex cat = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY); - Map metadataProperties = new HashMap<>(); - String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.RESOURCE_CATEGORY); - cat.setUniqueId(catId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); - metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_CATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME, categoryName); - metadataProperties - .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); - cat.setMetadataProperties(metadataProperties); - cat.updateMetadataJsonWithCurrentMetadataProperties(); - - GraphVertex subCat = new GraphVertex(VertexTypeEnum.RESOURCE_SUBCATEGORY); - metadataProperties = new HashMap<>(); - String subCatId = UniqueIdBuilder.buildSubCategoryUid(cat.getUniqueId(), subcategory); - subCat.setUniqueId(subCatId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, subCatId); - metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_SUBCATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME, subcategory); - metadataProperties - .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(subcategory)); - subCat.setMetadataProperties(metadataProperties); - subCat.updateMetadataJsonWithCurrentMetadataProperties(); - - Either catRes = titanDao.createVertex(cat); - Either subCatRes = titanDao.createVertex(subCat); - titanDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), - EdgeLabelEnum.SUB_CATEGORY, new HashMap<>()); - } - - private void createServiceCategory() { - GraphVertex cat = new GraphVertex(VertexTypeEnum.SERVICE_CATEGORY); - Map metadataProperties = new HashMap<>(); - String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.SERVICE_CATEGORY); - cat.setUniqueId(catId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); - metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.SERVICE_CATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME, categoryName); - metadataProperties - .put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); - cat.setMetadataProperties(metadataProperties); - cat.updateMetadataJsonWithCurrentMetadataProperties(); - titanDao.createVertex(cat); - } - - private void createRootNodeType() { - NodeType vf = new NodeType(); - String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); - vf.setUniqueId(uniqueId); - vf.setComponentType(ComponentTypeEnum.RESOURCE); - vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); - vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), "root"); - vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); - vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "1.0"); - vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VFC.name()); - vf.getMetadata() - .put(JsonPresentationFields.LIFECYCLE_STATE.getPresentation(), LifecycleStateEnum.CERTIFIED.name()); - vf.getMetadata().put(JsonPresentationFields.TOSCA_RESOURCE_NAME.getPresentation(), "root"); - vf.getMetadata().put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true); - - List categories = new ArrayList<>(); - CategoryDefinition cat = new CategoryDefinition(); - categories.add(cat); - cat.setName(categoryName); - List subCategories = new ArrayList<>(); - SubCategoryDefinition subCat = new SubCategoryDefinition(); - subCat.setName(subcategory); - subCategories.add(subCat); - cat.setSubcategories(subCategories); - vf.setCategories(categories); - - List derivedFrom = new ArrayList<>(); - vf.setDerivedFrom(derivedFrom); - - Map properties = new HashMap<>(); - PropertyDataDefinition prop1 = new PropertyDataDefinition(); - prop1.setName("derived1"); - prop1.setDefaultValue("deriveddef1"); - properties.put("derived1", prop1); - - PropertyDataDefinition prop2 = new PropertyDataDefinition(); - prop2.setUniqueId("derived2"); - prop2.setName("deriveddef2"); - properties.put("derived2", prop2); - - PropertyDataDefinition prop3 = new PropertyDataDefinition(); - prop3.setName("derived3"); - prop3.setDefaultValue("deriveddef3"); - properties.put("derived3", prop3); - - vf.setProperties(properties); - vf.setComponentType(ComponentTypeEnum.RESOURCE); - Either createVFRes = nodeTypeOperation.createNodeType(vf); - - Either getNodeTyeRes = - titanDao.getVertexById(createVFRes.left().value().getUniqueId()); - getNodeTyeRes.left().value(); - } - - private void createNodeType(String nodeTypeName, String uniqueId) { - NodeType vf = new NodeType(); - vf.setUniqueId(uniqueId); - vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); - vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), nodeTypeName); - vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); - vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); - vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); - vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); - List categories = new ArrayList<>(); - CategoryDefinition cat = new CategoryDefinition(); - categories.add(cat); - cat.setName(categoryName); - List subCategories = new ArrayList<>(); - SubCategoryDefinition subCat = new SubCategoryDefinition(); - subCat.setName(subcategory); - subCategories.add(subCat); - cat.setSubcategories(subCategories); - vf.setCategories(categories); - - List derivedFrom = new ArrayList<>(); - derivedFrom.add("root"); - vf.setDerivedFrom(derivedFrom); - - vf.setComponentType(ComponentTypeEnum.RESOURCE); - - List addProperties = new ArrayList<>(); - PropertyDataDefinition prop11 = new PropertyDataDefinition(); - prop11.setName("prop11"); - prop11.setDefaultValue("def11"); - - addProperties.add(prop11); - - PropertyDataDefinition prop22 = new PropertyDataDefinition(); - prop22.setName("prop22"); - prop22.setDefaultValue("def22"); - addProperties.add(prop22); - - Either createVFRes = nodeTypeOperation.createNodeType(vf); - Either getNodeTyeRes = - titanDao.getVertexById(createVFRes.left().value().getUniqueId()); - GraphVertex vfVertex = getNodeTyeRes.left().value(); - StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, - VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME); - assertSame(StorageOperationStatus.OK, status); - - PropertyDataDefinition prop33 = new PropertyDataDefinition(); - prop33.setName("prop33"); - prop33.setDefaultValue("def33"); - - status = nodeTypeOperation - .addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, - prop33, JsonPresentationFields.NAME); - assertSame(StorageOperationStatus.OK, status); - - PropertyDataDefinition prop44 = new PropertyDataDefinition(); - prop44.setName("prop44"); - prop44.setDefaultValue("def44"); - - status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, - VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME); - assertSame(StorageOperationStatus.OK, status); - - PropertyDataDefinition capProp = new PropertyDataDefinition(); - capProp.setName("capProp"); - capProp.setDefaultValue("capPropDef"); - - MapDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - dataToCreate.put("capProp", capProp); - - Map capProps = new HashMap<>(); - capProps.put("capName", dataToCreate); - - nodeTypeOperation.associateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, - EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); - - List pathKeys = new ArrayList<>(); - pathKeys.add("capName"); - capProp.setDefaultValue("BBBB"); - nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, - VertexTypeEnum.CAPABILITIES_PROPERTIES, capProp, pathKeys, JsonPresentationFields.NAME); - } - - private void createTopologyTemplate(String name) { - TopologyTemplate service = new TopologyTemplate(); - String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); - service.setUniqueId(uniqueId); - service.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID)); - service.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), name); - service.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); - service.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); - service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); - service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); - List categories = new ArrayList<>(); - CategoryDefinition cat = new CategoryDefinition(); - categories.add(cat); - cat.setName(categoryName); - service.setCategories(categories); - - service.setComponentType(ComponentTypeEnum.SERVICE); - Either createRes = - topologyTemplateOperation.createTopologyTemplate(service); - Either getNodeTyeRes = - titanDao.getVertexById(createRes.left().value().getUniqueId()); - - getNodeTyeRes.left().value(); - } - - @After - public void cleanAfter() { - GraphTestUtils.clearGraph(titanDao); - } - - @Test - public void testAddInterface_Service() { - testAddSingleInterface(service); - } - - private void testAddSingleInterface(Component component) { - InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); - Either, StorageOperationStatus> res = interfaceOperation - .addInterfaces(component.getUniqueId(), - Collections.singletonList( - interfaceDefinition)); - Assert.assertTrue(res.isLeft()); - Assert.assertEquals("1", res.left().value().get(0).getUniqueId()); - } - - private InterfaceDefinition buildInterfaceDefinition(String uniqueId) { - InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); - interfaceDefinition.setType("tosca.interfaces.standard"); - interfaceDefinition.setUniqueId(uniqueId); - interfaceDefinition.setOperationsMap(createMockOperationMap()); - return interfaceDefinition; - } - - private Map createMockOperationMap() { - Map operationMap = new HashMap<>(); - operationMap.put("op1", createMockOperation()); - return operationMap; - } - - private Operation createMockOperation() { - Operation operation = new Operation(); - operation.setDefinition(false); - operation.setName("create"); - operation.setUniqueId("op1"); - return operation; - } - - @Test - public void testAddInterface_Resource() { - testAddMultipleInterface(resource); - } - - private void testAddMultipleInterface(Component component) { - InterfaceDefinition interfaceDefinition1 = buildInterfaceDefinition("1"); - InterfaceDefinition interfaceDefinition2 = buildInterfaceDefinition("2"); - List interfaceDefinitions = new ArrayList<>(); - interfaceDefinitions.add(interfaceDefinition1); - interfaceDefinitions.add(interfaceDefinition2); - Either, StorageOperationStatus> res = - interfaceOperation.addInterfaces(component.getUniqueId(), interfaceDefinitions); - Assert.assertTrue(res.isLeft()); - Assert.assertEquals(2, res.left().value().size()); - } - - @Test - public void testUpdateInterface_Service() { - testUpdateInterface(service); - } - - private void testUpdateInterface(Component component) { - InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); - Either, StorageOperationStatus> res = interfaceOperation - .addInterfaces(component.getUniqueId(), - Collections.singletonList( - interfaceDefinition)); - Assert.assertTrue(res.isLeft()); - List value = res.left().value(); - InterfaceDefinition createdInterfaceDef = value.get(0); - String newDescription = "New Description"; - createdInterfaceDef.setDescription(newDescription); - res = interfaceOperation - .updateInterfaces(component.getUniqueId(), Collections.singletonList(createdInterfaceDef)); - assertTrue(res.isLeft()); - assertEquals(newDescription, res.left().value().get(0).getDescription()); - } - - @Test - public void testUpdateInterface_Resource() { - testUpdateInterface(resource); - } - - @Test - public void testDeleteInterface_Service() { - testDeleteInterface(service); - } - - private void testDeleteInterface(Component component) { - InterfaceDefinition interfaceDefinition = buildInterfaceDefinition("1"); - Either, StorageOperationStatus> res = interfaceOperation - .addInterfaces(component.getUniqueId(), - Collections.singletonList( - interfaceDefinition)); - Assert.assertTrue(res.isLeft()); - List value = res.left().value(); - Either deleteInterfaceOperationRes = - interfaceOperation.deleteInterface(component.getUniqueId(), value.get(0).getUniqueId()); - assertTrue(deleteInterfaceOperationRes.isLeft()); - } - - @Test - public void testDeleteInterface_Resource() { - testDeleteInterface(resource); - } - - @Test - public void testUpdateInterfaceShouldFailWhenNOtCreatedFirst() { - Component component = createResource(); - InterfaceDefinition interfaceDefinition = buildInterfaceDefinitionWithoutOperation(); - interfaceDefinition.setOperationsMap(createMockOperationMap()); - Either, StorageOperationStatus> res = interfaceOperation.updateInterfaces( - component.getUniqueId(), Collections.singletonList(interfaceDefinition)); - Assert.assertTrue(res.isRight()); - } - - private InterfaceDefinition buildInterfaceDefinitionWithoutOperation() { - InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); - interfaceDefinition.setType("tosca.interfaces.standard"); - return interfaceDefinition; - } - - private org.openecomp.sdc.be.model.Resource createResource() { - org.openecomp.sdc.be.model.Resource resource = new org.openecomp.sdc.be.model.Resource(); - resource.setUniqueId(RESOURCE_ID); - resource.setName(RESOURCE_NAME); - resource.setDescription("My short description"); - resource.setInterfaces(createMockInterfaceDefinition()); - return resource; - } - - private Service createService() { - Service service = new Service(); - service.setUniqueId(SERVICE_ID); - service.setName(SERVICE_NAME); - service.setDescription("My short description"); - service.setInterfaces(createMockInterfaceDefinition()); - return service; - } - - private Map createMockInterfaceDefinition() { - Map operationMap = createMockOperationMap(); - Map interfaceDefinitionMap = new HashMap<>(); - interfaceDefinitionMap.put("int1", createInterface("int1", "Interface 1", "lifecycle", "tosca", operationMap)); - return interfaceDefinitionMap; - } - - private InterfaceDefinition createInterface(String uniqueId, String description, String type, - String toscaResourceName, Map op) { - InterfaceDefinition id = new InterfaceDefinition(); - id.setType(type); - id.setDescription(description); - id.setUniqueId(uniqueId); - id.setToscaResourceName(toscaResourceName); - id.setOperationsMap(op); - return id; - } - - @After - public void teardown() { - GraphTestUtils.clearGraph(titanDao); - } - -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java deleted file mode 100644 index 1887891f2b..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java +++ /dev/null @@ -1,244 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import java.io.BufferedOutputStream; -import java.io.File; -import java.io.FileOutputStream; -import java.io.OutputStream; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import javax.annotation.Resource; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.apache.tinkerpop.gremlin.structure.io.IoCore; -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.config.TitanSpringConfig; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) -public class NodeTemplateOperationGraphTest extends ModelTestBase{ - @Resource - private HealingTitanDao titanDao; - @Resource - private NodeTemplateOperation nodeTemplateOperation; - - private TitanGraph graphT; - private GraphVertex containerVertex; - private String containeId; - - @BeforeClass - public static void setupBeforeClass() { - - ModelTestBase.init(); - } - @Before - public void before(){ - - Either graph = titanDao.getGraph(); - graphT = graph.left().value(); - - containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); - containeId = "containerId"; - containerVertex.setUniqueId(containeId); - Either createVertex = titanDao.createVertex(containerVertex); - assertTrue(createVertex.isLeft()); - } - - @After - public void after(){ - titanDao.rollback(); - - } - - - String outputDirectory = "C:\\Output"; - - @Test - public void testCreateInstanceEdge(){ - - Map> mapOriginToInstId = new HashMap<>(); - createIntancesFromSameResource(mapOriginToInstId, 1, 3); - createIntancesFromSameResource(mapOriginToInstId, 2, 4); - createIntancesFromSameResource(mapOriginToInstId, 3, 1); - -// exportGraphMl(graphT); - - validateOnGraph(mapOriginToInstId, 3); - } - - @Test - public void testRemoveInstanceEdge(){ - //create 3 instances from same resource orig1 - Map> mapOriginToInstId = new HashMap<>(); - String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3); - validateOnGraph(mapOriginToInstId, 1); - - //remove instance 2 - String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1); - mapOriginToInstId.get(originId).remove(instanceId); - validateOnGraph(mapOriginToInstId, 1); - - //create new instance from orig1 - instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null); - mapOriginToInstId.get(originId).add(instanceId); - validateOnGraph(mapOriginToInstId, 1); - - //create 1 instance from same resource orig2 - originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1); - validateOnGraph(mapOriginToInstId, 2); - - //remove instance of orig 2 - instanceId = removeInstanceEdge(containerVertex, originId, 2, 1); - mapOriginToInstId.get(originId).remove(instanceId); - validateOnGraph(mapOriginToInstId, 1); - - } - - @Test - public void testProxyInstanceEdge(){ - Map> mapOriginToInstId = new HashMap<>(); - String proxyId = createOrigin(2); - createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId); - - validateOnGraph(mapOriginToInstId, 1); - } - private void validateOnGraph(Map> mapOriginToInstId, int expectedEdgeCount) { - validateOnGraph(mapOriginToInstId, expectedEdgeCount, false); - } - private void validateOnGraph(Map> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) { - Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices(); - assertNotNull(vertices); - Iterator iterator = vertices.iterator(); - assertTrue(iterator.hasNext()); - Vertex containerV = iterator.next(); - validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF); - if ( validateProxy ){ - validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF); - } - } - private void validatePerEdgeType(Map> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) { - Iterator edges = containerV.edges(Direction.OUT, edgeLabel.name()); - assertNotNull(edges); - - int counter = 0; - while (edges.hasNext()){ - Edge edge = edges.next(); - counter++; - validateEdge(edge, mapOriginToInstId); - } - assertEquals("check edge size", expectedEdgeCount, counter); - } - - - private String createIntancesFromSameResource(Map> mapOriginToInstId, int originIndex, int countInstances) { - return createIntancesFromSameResource(mapOriginToInstId, originIndex, countInstances, false, null); - } - - private String createIntancesFromSameResource(Map> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) { - - List exp = new ArrayList(); - String originId = createOrigin(originIndex); - - for ( int i = 0; i < countInstances; i++){ - String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId); - exp.add(instanceId); - } - mapOriginToInstId.put(originId, exp); - if ( isProxy ){ - mapOriginToInstId.put(proxyId, exp); - } - return originId; - } - - private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) { - ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); - componentInstance.setComponentUid(originId); - String instanceId = buildInstanceId(originIndex, insIndex); - componentInstance.setUniqueId(instanceId); - componentInstance.setIsProxy(isProxy); - componentInstance.setSourceModelUid(proxyId); - StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance); - assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus); - return instanceId; - } - - private String buildInstanceId(int originIndex, int insIndex) { - StringBuffer sb = new StringBuffer("instanceId_"); - sb.append(originIndex).append("-").append(insIndex); - return sb.toString(); - } - private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) { - ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); - componentInstance.setComponentUid(originId); - String instanceId = buildInstanceId(originIndex, insIndex); - componentInstance.setUniqueId(instanceId); - StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance); - assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus); - return instanceId; - } - - - private String createOrigin(int index) { - Either createVertex; - GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE); - String originId = "originId_" + index; - originVertex.setUniqueId(originId); - createVertex = titanDao.createVertex(originVertex); - assertTrue(createVertex.isLeft()); - return originId; - } - private void validateEdge(Edge edge, Map> mapOriginToInstId) { - List expextedInList; - - Vertex originV = edge.inVertex(); - String id = (String) titanDao.getProperty((TitanVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty()); - expextedInList = mapOriginToInstId.get(id); - - List list = (List) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES); - assertThat(list).hasSameSizeAs(expextedInList); - assertThat(list).containsOnlyElementsOf(expextedInList); - } - - private String exportGraphMl(TitanGraph graph) { - String result = null; - String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml"; - try { - try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) { - graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph); - } - result = outputFile; - } catch (Exception e) { - e.printStackTrace(); - } - return result; - - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java deleted file mode 100644 index bddebea630..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java +++ /dev/null @@ -1,364 +0,0 @@ -/* - - * Copyright (c) 2018 AT&T Intellectual Property. - - * - - * Licensed under the Apache License, Version 2.0 (the "License"); - - * you may not use this file except in compliance with the License. - - * You may obtain a copy of the License at - - * - - * http://www.apache.org/licenses/LICENSE-2.0 - - * - - * Unless required by applicable law or agreed to in writing, software - - * distributed under the License is distributed on an "AS IS" BASIS, - - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - - * See the License for the specific language governing permissions and - - * limitations under the License. - - */ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.google.common.collect.Lists; -import fj.data.Either; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.*; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.*; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.when; - -@RunWith(MockitoJUnitRunner.class) -public class NodeTemplateOperationTest extends ModelTestBase { - - private final static String COMPONENT_ID = "componentId"; - private final static String TO_INSTANCE_ID = "toInstanceId"; - private final static String FROM_INSTANCE_ID = "fromInstanceId"; - private final static String RELATION_ID = "relationId"; - private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId"; - private final static String CAPABILITY_UID = "capabilityUid"; - private final static String CAPABILITY_NAME = "capabilityName"; - private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId"; - private final static String REQUIREMENT_UID = "requirementUid"; - private final static String REQUIREMENT_NAME = "requirementName"; - private final static String RELATIONSHIP_TYPE = "relationshipType"; - - private static Map fulfilledCapability; - private static Map fulfilledRequirement; - private static CapabilityDataDefinition capability; - private static RequirementDataDefinition requirement; - private static RequirementCapabilityRelDef relation; - - @InjectMocks - private static NodeTemplateOperation operation; - - @Mock - private static TitanDao titanDao; - - @Mock - private static TopologyTemplateOperation topologyTemplateOperation; - - @BeforeClass - public static void setup() { - init(); - titanDao = Mockito.mock(TitanDao.class); - operation = new NodeTemplateOperation(); - operation.setTitanDao(titanDao); - buildDataDefinition(); - } - - private static void buildDataDefinition() { - buildCapabiltyDataDefinition(); - buildRequirementDataDefinition(); - buildRelation(); - } - - @Test - public void testGetFulfilledCapabilityByRelationSuccess(){ - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - GraphVertex dataVertex = new GraphVertex(); - dataVertex.setJson(fulfilledCapability); - Either childVertexRes = Either.left(dataVertex); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); - assertTrue(result.isLeft()); - assertEquals(result.left().value(), capability); - } - - @Test - public void testGetFulfilledRequirementByRelationSuccess(){ - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - GraphVertex dataVertex = new GraphVertex(); - dataVertex.setJson(fulfilledRequirement); - Either childVertexRes = Either.left(dataVertex); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); - assertTrue(result.isLeft()); - assertEquals(result.left().value(), requirement); - } - - @Test - public void testGetFulfilledCapabilityByRelationNotFoundFailure(){ - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - Either childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); - assertTrue(result.isRight()); - assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); - } - - @Test - public void testGetFulfilledRequirementByRelationNotFoundFailure(){ - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - Either childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); - assertTrue(result.isRight()); - assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); - } - - @Test - public void testUpdateCIMetadataOfTopologyTemplate() { - Either, StorageOperationStatus> result; - String id = "id"; - TopologyTemplate container = new TopologyTemplate(); - ToscaElement toscaElement = new TopologyTemplate(); - toscaElement.setResourceType(ResourceTypeEnum.VF); - ComponentInstance componentInstance = new ComponentInstance(); - componentInstance.setName(id); - componentInstance.setComponentUid(id); - container.setUniqueId(id); - GraphVertex graphVertex = new GraphVertex(); - when(titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex)); - when(titanDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex)); - when(topologyTemplateOperation.getToscaElement(anyString())).thenReturn(Either.left(toscaElement)); - - result = operation.updateComponentInstanceMetadataOfTopologyTemplate(container, toscaElement, componentInstance); - assertTrue(result.isLeft()); - } - - @Test - public void testGetDefaultHeatTimeout() { - Integer result; - - // default test - result = NodeTemplateOperation.getDefaultHeatTimeout(); - } - - @Test - public void testPrepareInstDeploymentArtifactPerInstance() { - Map deploymentResourceArtifacts = new HashMap<>(); - Map deploymentArtifacts = new HashMap<>(); - ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition(); - artifactDataDefinition.setArtifactType("HEAT"); - artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT); - deploymentArtifacts.put("1", artifactDataDefinition); - deploymentResourceArtifacts.put("1", artifactDataDefinition); - String componentInstanceId = "componentInstanceId"; - User user = new User(); - user.setUserId("userId"); - user.setFirstName("first"); - user.setLastName("last"); - String envType = "VfHeatEnv"; - MapArtifactDataDefinition result; - - result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user, - envType); - Assert.assertEquals(2, result.getMapToscaDataDefinition().size()); - } - - @Test - public void testCreateCapPropertyKey() throws Exception { - String key = ""; - String instanceId = ""; - String result; - - // default test - result = NodeTemplateOperation.createCapPropertyKey(key, instanceId); - } - - @Test - public void testPrepareCalculatedCapabiltyForNodeType() { - Map capabilities = new HashMap<>(); - ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition(); - List listToscaDataDefinition = new ArrayList<>(); - CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition(); - capabilityDataDefinition.setMaxOccurrences("1"); - listToscaDataDefinition.add(capabilityDataDefinition); - listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition); - capabilities.put("1", listCapDataDefinition); - ComponentInstance componentInstance = createCompInstance(); - MapListCapabilityDataDefinition result; - - result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance); - Assert.assertEquals(1, result.getMapToscaDataDefinition().size()); - } - - @Test - public void testPrepareCalculatedReqForNodeType() { - Map requirements = new HashMap<>(); - ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition(); - List listToscaDataDefinition = new ArrayList<>(); - RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition(); - reqDataDefinition.setMaxOccurrences("1"); - listToscaDataDefinition.add(reqDataDefinition); - listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition); - requirements.put("1", listReqDataDef); - ComponentInstance componentInstance = createCompInstance(); - MapListRequirementDataDefinition result; - - result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance); - Assert.assertEquals(1, result.getMapToscaDataDefinition().size()); - } - - @Test - public void testAddGroupInstancesToComponentInstance() throws Exception { - Component containerComponent = null; - ComponentInstanceDataDefinition componentInstance = null; - List groups = null; - Map> groupInstancesArtifacts = null; - StorageOperationStatus result; - - result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups, - groupInstancesArtifacts); - Assert.assertEquals(StorageOperationStatus.OK, result); - } - - @Test - public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception { - String componentId = ""; - String instanceId = ""; - List groupInstances = null; - StorageOperationStatus result; - - result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances); - Assert.assertEquals(StorageOperationStatus.OK, result); - } - - private ComponentInstance createCompInstance() { - ComponentInstance componentInstance = new ComponentInstance(); - String id = "id"; - componentInstance.setComponentUid(id); - componentInstance.setUniqueId(id); - componentInstance.setName(id); - return componentInstance; - } - private static void buildRequirementDataDefinition() { - buildRequirement(); - fulfilledRequirement = new HashMap<>(); - MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition(); - mapListRequirementDataDefinition.add(requirement.getCapability(), requirement); - fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition); - - } - - private static void buildRequirement() { - requirement = new RequirementDataDefinition(); - requirement.setOwnerId(REQUIREMENT_OWNER_ID); - requirement.setUniqueId(REQUIREMENT_UID); - requirement.setName(REQUIREMENT_NAME); - requirement.setRelationship(RELATIONSHIP_TYPE); - } - - private static void buildCapabiltyDataDefinition() { - buildCapability(); - fulfilledCapability = new HashMap<>(); - MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition(); - mapListCapabiltyDataDefinition.add(capability.getType(), capability); - fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition); - } - - private static void buildCapability() { - capability = new CapabilityDataDefinition(); - capability.setOwnerId(CAPABILITY_OWNER_ID); - capability.setUniqueId(CAPABILITY_UID); - capability.setName(CAPABILITY_NAME); - } - - private static void buildRelation() { - - relation = new RequirementCapabilityRelDef(); - CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); - RelationshipInfo relationInfo = new RelationshipInfo(); - relationInfo.setId(RELATION_ID); - relationship.setRelation(relationInfo); - - relation.setRelationships(Lists.newArrayList(relationship)); - relation.setToNode(TO_INSTANCE_ID); - relation.setFromNode(FROM_INSTANCE_ID); - - relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID); - relationInfo.setCapabilityUid(CAPABILITY_UID); - relationInfo.setCapability(CAPABILITY_NAME); - relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID); - relationInfo.setRequirementUid(REQUIREMENT_UID); - relationInfo.setRequirement(REQUIREMENT_NAME); - RelationshipImpl relationshipImpl = new RelationshipImpl(); - relationshipImpl.setType(RELATIONSHIP_TYPE); - relationInfo.setRelationships(relationshipImpl); - } - - private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) { - return req.getRelationship().equals(relationshipInfo.getRelationship().getType()) && - req.getName().equals(relationshipInfo.getRequirement()) && - req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && - req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId()); - } - - private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) { - return cap.getName().equals(relationshipInfo.getCapability()) && - cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && - cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId()); - } - -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java deleted file mode 100644 index ca8713fdf3..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java +++ /dev/null @@ -1,134 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.config.TitanSpringConfig; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import javax.annotation.Resource; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import static org.apache.commons.collections.ListUtils.union; -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) -public class PolicyOperationIntegrationTest extends ModelTestBase { - - private static final String CONTAINER_ID = "container"; - public static final String POLICY_ID = "policy"; - @Resource - private TopologyTemplateOperation topologyTemplateOperation; - @Resource - private HealingTitanDao titanDao; - @Resource - private PolicyOperation policyOperation; - private PropertyDataDefinition prop1, prop2; - private PolicyDefinition policy; - - @BeforeClass - public static void setupBeforeClass() { - - ModelTestBase.init(); - } - - @Before - public void setUp() throws Exception { - prop1 = new PropertyDataDefinition(); - prop1.setUniqueId("prop1"); - prop1.setName("prop1"); - prop1.setValue("prop1"); - - prop2 = new PropertyDataDefinition(); - prop2.setUniqueId("prop2"); - prop2.setName("prop2"); - prop2.setValue("prop2"); - - policy = new PolicyDefinition(); - policy.setUniqueId(POLICY_ID); - - policy.setProperties(Arrays.asList(prop1, prop2)); - - GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); - resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); - titanDao.createVertex(resource); - GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); - topologyTemplateOperation.addToscaDataToToscaElement(loadedResource, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policy, JsonPresentationFields.UNIQUE_ID); -// titanDao.commit(); - } - - @After - public void tearDown() { - titanDao.rollback(); - } - - @Test - public void testUpdatePolicyProperties_singleProperty() { - PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); - prop1Copy.setValue("prop1NewValue"); - testUpdatePolicyProperties(Collections.singletonList(prop1Copy), Collections.singletonList(prop2)); - } - - @Test - public void testUpdatePolicyProperties_multipleProperties() { - PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); - prop1Copy.setValue("prop1NewValue"); - - PropertyDataDefinition prop2Copy = new PropertyDataDefinition(prop2); - prop2Copy.setValue("prop2NewValue"); - - testUpdatePolicyProperties(Arrays.asList(prop1Copy, prop2Copy), Collections.emptyList()); - } - - private void testUpdatePolicyProperties(List updatedProperties, List nonUpdatedPropeties) { - Component cmpt = new org.openecomp.sdc.be.model.Resource(); - cmpt.setUniqueId(CONTAINER_ID); - cmpt.setPolicies(Collections.singletonMap(POLICY_ID, policy)); - StorageOperationStatus storageOperationStatus = policyOperation.updatePolicyProperties(cmpt, POLICY_ID, updatedProperties); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); - - ComponentParametersView componentParametersView = new ComponentParametersView(); - componentParametersView.disableAll(); - componentParametersView.setIgnorePolicies(false); - Either loadedCmptEither = topologyTemplateOperation.getToscaElement(CONTAINER_ID, componentParametersView); - - assertThat(loadedCmptEither.isLeft()).isTrue(); - ToscaElement loadedCmpt = loadedCmptEither.left().value(); - assertThat(loadedCmpt).isInstanceOf(TopologyTemplate.class); - @SuppressWarnings("unchecked") List allProperties = union(updatedProperties, nonUpdatedPropeties); - verifyPolicyPropertiesValuesUpdated((TopologyTemplate) loadedCmpt, allProperties); - } - - private void verifyPolicyPropertiesValuesUpdated(TopologyTemplate toscaElement, List expectedUpdatedProperties) { - Map policies = toscaElement.getPolicies(); - PolicyDataDefinition policy = policies.get(POLICY_ID); - List policyProperties = policy.getProperties(); - assertThat(policyProperties).usingElementComparatorOnFields("value") - .containsAll(expectedUpdatedProperties); - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java deleted file mode 100644 index 136f95b987..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java +++ /dev/null @@ -1,93 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Captor; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; - -import java.util.Arrays; -import java.util.Collections; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.verifyZeroInteractions; -import static org.mockito.Mockito.when; - -@RunWith(MockitoJUnitRunner.class) -public class PolicyOperationTest { - - private static final String CONTAINER_ID = "containerId"; - private static final String POLICY_ID = "policyId"; - @InjectMocks - private PolicyOperation testInstance; - @Mock - private TitanDao titanDao; - @Mock - private TopologyTemplateOperation topologyTemplateOperation; - @Captor - private ArgumentCaptor policyDefCaptor; - private Component component; - private PolicyDefinition policyDefinition; - private PropertyDataDefinition prop1, prop2; - - @Before - public void setUp() throws Exception { - component = new Resource(); - component.setUniqueId(CONTAINER_ID); - policyDefinition = new PolicyDefinition(); - policyDefinition.setUniqueId(POLICY_ID); - prop1 = new PropertyDataDefinition(); - prop1.setName("prop1"); - prop1.setValue("prop1"); - - prop2 = new PropertyDataDefinition(); - prop2.setName("prop2"); - prop2.setValue("prop2"); - policyDefinition.setProperties(Arrays.asList(prop1, prop2)); - component.setPolicies(Collections.singletonMap(POLICY_ID, policyDefinition)); - } - - @Test - public void updatePolicyProperties_failedToFetchContainer() { - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); - verifyZeroInteractions(topologyTemplateOperation); - } - - @Test - public void updatePolicyProperties_updateFailed() { - GraphVertex cmptVertex = new GraphVertex(); - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); - when(topologyTemplateOperation.updatePolicyOfToscaElement(cmptVertex, policyDefinition)).thenReturn(StorageOperationStatus.GENERAL_ERROR); - StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.GENERAL_ERROR); - } - - @Test - public void updatePolicyProperties() { - GraphVertex cmptVertex = new GraphVertex(); - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); - when(topologyTemplateOperation.updatePolicyOfToscaElement(eq(cmptVertex), policyDefCaptor.capture())).thenReturn(StorageOperationStatus.OK); - PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); - prop1Copy.setValue("prop1Copy"); - StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.singletonList(prop1Copy)); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); - assertThat(policyDefCaptor.getValue().getProperties()).usingElementComparatorOnFields("value") - .containsExactlyInAnyOrder(prop1Copy, prop2); - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java deleted file mode 100644 index 9936d45f62..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java +++ /dev/null @@ -1,198 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.config.TitanSpringConfig; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.PropertyDefinition; -import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import javax.annotation.Resource; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) -public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTestBase { - - private static final String CONTAINER_ID = "id"; - private Map capabilitiesPropsMap; - private List capabilitiesProperties; - - @Resource - private TopologyTemplateOperation topologyTemplateOperation; - - @Resource - private HealingTitanDao titanDao; - private CapabilityPropertyDataObject capabilityProperty1; - private CapabilityPropertyDataObject capabilityProperty2; - private CapabilityPropertyDataObject capabilityProperty3; - - @BeforeClass - public static void setupBeforeClass() { - - ModelTestBase.init(); - } - - @Before - public void setUp() throws Exception { - - capabilitiesPropsMap = new HashMap<>(); - capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1"); - capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2"); - capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3"); - capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3); - - - //capablities props == Map>> - capabilitiesProperties.forEach(capabilitiesProperty -> { - capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabilityProperty(new HashMap<>())) - .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>())) - .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue()))); - }); - - GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); - resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); - titanDao.createVertex(resource); - GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); - topologyTemplateOperation.associateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value(); - } - - @After - public void tearDown() { - titanDao.rollback(); - } - - @Test - public void overrideCalculatedCapabilityProperties() { - Map loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); - compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap); - capabilityProperty1.setPropValue("newVal1"); - capabilityProperty3.setPropValue("newVal3"); - setPropertyValue(capabilitiesPropsMap, capabilityProperty1); - setPropertyValue(capabilitiesPropsMap, capabilityProperty3); - StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); - Map updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); - compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap); - } - - @Test - public void updateToscaDataDeepElementsBlockToToscaElement() { - assertCapabilityPropValue(capabilityProperty1, "val1"); - assertCapabilityPropValue(capabilityProperty2, "val2"); - assertCapabilityPropValue(capabilityProperty3, "val3"); - - MapCapabilityProperty instance1Props = capabilitiesPropsMap.get("instance1"); - capabilityProperty1.setPropValue("newVal1"); - setPropertyValue(capabilitiesPropsMap, capabilityProperty1); - - capabilityProperty3.setPropValue("newVal3"); - setPropertyValue(capabilitiesPropsMap, capabilityProperty3); - - Component component = new org.openecomp.sdc.be.model.Resource(); - component.setUniqueId(CONTAINER_ID); - StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1"); - - assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK); - assertCapabilityPropValue(capabilityProperty1, "newVal1"); - assertCapabilityPropValue(capabilityProperty2, "val2"); - assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated - } - - private Map fetchCapabilitiesProps(String containerId) { - ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true); - capabilityPropsFilter.setIgnoreCapabiltyProperties(false); - return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties(); - } - - private void compareCapabilitiesProperties(List expected, Map actual) { - expected.forEach(expectedCapabilityProp -> { - assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName)) - .isEqualTo(expectedCapabilityProp.propValue); - }); - } - - private String getPropertyValue(Map capabilityPropertyMap, String instance, String capability, String prop) { - return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue(); - } - - private void setPropertyValue(Map capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) { - setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty); - - } - - private void setPropertyValue(MapCapabilityProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) { - capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId()) - .getMapToscaDataDefinition().get(capabilityProperty.getPropName()) - .setValue(capabilityProperty.getPropValue()); - } - - private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) { - Map loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); - String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName()); - assertThat(propertyValue).isEqualTo(expectedValue); - } - - - private PropertyDefinition createPropWithValue(String val) { - PropertyDefinition propertyDefinition = new PropertyDefinition(); - propertyDefinition.setValue(val); - return propertyDefinition; - } - - private static class CapabilityPropertyDataObject { - private String instanceId; - private String capabilityId; - private String propName; - private String propValue; - - CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) { - this.instanceId = instanceId; - this.capabilityId = capabilityId; - this.propName = propName; - this.propValue = propValue; - } - - String getInstanceId() { - return instanceId; - } - - String getCapabilityId() { - return capabilityId; - } - - String getPropName() { - return propName; - } - - String getPropValue() { - return propValue; - } - - void setPropValue(String propValue) { - this.propValue = propValue; - } - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java deleted file mode 100644 index 4ace70b34f..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java +++ /dev/null @@ -1,177 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.model.DistributionStatusEnum; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; - -import java.util.*; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.when; - -@RunWith(MockitoJUnitRunner.class) -//error scenarios -public class TopologyTemplateOperationTest { - - private static final String CONTAINER_ID = "containerId"; - @InjectMocks - private TopologyTemplateOperation topologyTemplateOperation; - @Mock - private TitanDao titanDao; - - @Test - public void overrideToscaDataOfToscaElement_failedToFetchContainerVertex() { - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID)); - StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); - } - - @Test - public void overrideToscaDataOfToscaElement_failedToFetchDataVertex() { - GraphVertex containerVertex = new GraphVertex(); - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); - when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); - } - - @Test - public void updateToscaDataDeepElements_failedToFetchContainerVertex() { - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID)); - StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); - } - - @Test - public void updateToscaDataDeepElements_failedToFetchDataVertex() { - GraphVertex containerVertex = new GraphVertex(); - when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); - when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); - } - - @Test - public void addPolicyToToscaElementSuccessTest(){ - TitanOperationStatus status = TitanOperationStatus.OK; - StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); - assertThat(result).isEqualTo(StorageOperationStatus.OK); - } - - @Test - public void addPolicyToToscaElementFailureTest(){ - TitanOperationStatus status = TitanOperationStatus.ALREADY_EXIST; - StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); - assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS); - } - - @Test - public void testAssociateOrAddCalcCapReqToComponent() { - StorageOperationStatus result; - GraphVertex graphVertex = new GraphVertex(); - Map calcRequirements = new HashMap<>(); - Map calcCapabilty = new HashMap<>(); - Map calCapabilitiesProps = new HashMap<>(); - addPolicyToToscaElementWithStatus(TitanOperationStatus.OK); - result = topologyTemplateOperation.associateOrAddCalcCapReqToComponent(graphVertex, calcRequirements, calcCapabilty, calCapabilitiesProps); - assertEquals(StorageOperationStatus.OK, result); - } - - @Test - public void testSetDataTypesFromGraph() { - GraphVertex containerVertex = new GraphVertex(); - ComponentParametersView filter = new ComponentParametersView(true); - filter.setIgnoreComponentInstancesInterfaces(true); - filter.setIgnoreDataType(false); - String componentName = "componentName"; - String componentId = UniqueIdBuilder.buildResourceUniqueId(); - containerVertex.setVertex(Mockito.mock(TitanVertex.class)); - containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName); - containerVertex.setUniqueId(componentId); - containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); - when(titanDao.getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); - Either storageOperationStatus = topologyTemplateOperation.getToscaElement(containerVertex, filter); - assertThat(storageOperationStatus).isEqualTo(Either.right(StorageOperationStatus.GENERAL_ERROR)); - } - - @Test - public void testUpdateDistributionStatus() { - Either result; - String uniqueId = "uniqueId"; - User user = new User(); - String userId = "userId"; - user.setUserId(userId); - Iterator edgeIterator = new Iterator() { - @Override - public boolean hasNext() { - return false; - } - - @Override - public Edge next() { - return null; - } - }; - GraphVertex graphVertex = Mockito.mock(GraphVertex.class); - TitanVertex titanVertex = Mockito.mock(TitanVertex.class); - when(graphVertex.getVertex()).thenReturn(titanVertex); - when(titanVertex.edges(Direction.IN, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER.name())).thenReturn(edgeIterator); - when(titanDao.getVertexByPropertyAndLabel(GraphPropertyEnum.USERID, userId, VertexTypeEnum.USER, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); - when(titanDao.getVertexById(uniqueId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex)); - when(titanDao.createEdge(graphVertex, graphVertex, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER, null)).thenReturn(TitanOperationStatus.OK); - when(titanDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex)); - result = topologyTemplateOperation.updateDistributionStatus(uniqueId, user, DistributionStatusEnum.DISTRIBUTED); - assertThat(result.isLeft()); - } - - @SuppressWarnings("unchecked") - private StorageOperationStatus addPolicyToToscaElementWithStatus(TitanOperationStatus status) { - GraphVertex componentV = new GraphVertex(); - componentV.setVertex(Mockito.mock(TitanVertex.class)); - GraphVertex dataV = new GraphVertex(); - dataV.setVertex(Mockito.mock(TitanVertex.class)); - String componentName = "componentName"; - String componentId = UniqueIdBuilder.buildResourceUniqueId(); - String policyTypeName = "org.openecomp.policies.placement.valet.Affinity"; - componentV.setJsonMetadataField(JsonPresentationFields.NAME, componentName); - componentV.setUniqueId(componentId); - PolicyDefinition policy = new PolicyDefinition(); - policy.setPolicyTypeName(policyTypeName); - int counter = 0; - Either toscaDataVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); - when(titanDao.getChildVertex(eq(componentV), eq(EdgeLabelEnum.POLICIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(toscaDataVertexRes); - Either createVertex = Either.left(dataV); - when(titanDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex); - when(titanDao.createEdge(any(TitanVertex.class), any(TitanVertex.class), any(EdgeLabelEnum.class), any(HashMap.class))).thenReturn(status); - return topologyTemplateOperation.addPolicyToToscaElement(componentV, policy, counter); - } - -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java deleted file mode 100644 index bffefd86cd..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java +++ /dev/null @@ -1,73 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.apache.tinkerpop.gremlin.structure.VertexProperty; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.model.catalog.CatalogComponent; - -import java.util.ArrayList; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - -@RunWith(MockitoJUnitRunner.class) -public class ToscaElementOperationCatalogTest { - - private ArrayList vertexList = new ArrayList<>(); - - @Mock - Vertex vertex; - @Mock - TitanDao titanDao; - @Mock - VertexProperty property; - - @InjectMocks - private ToscaElementOperation toscaOperation = new TopologyTemplateOperation(); - - @Before - public void setUp() { - vertexList.add(vertex); - when(titanDao.getCatalogOrArchiveVerticies(true)).thenReturn(Either.left(vertexList.iterator())); - when(titanDao.getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse)) - .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - when(vertex.property(GraphPropertiesDictionary.METADATA.getProperty())).thenReturn(property); - } - - @Test - public void getComponentFromCatalogWhenDeleteIsTrue() { - final String vertexJsonIsDeletedTrue = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":true,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; - when(property.value()).thenReturn(vertexJsonIsDeletedTrue); - List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); - assertTrue(componentList.isEmpty()); - } - - @Test - public void getComponentFromCatalogWhenDeleteNotFound() { - final String vertexJsonIsDeletedNotFound = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; - when(property.value()).thenReturn(vertexJsonIsDeletedNotFound); - List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); - assertEquals(1, componentList.size()); - } - - @Test - public void getComponentFromCatalogWhenDeleteIsFalse() { - final String vertexJsonIsDeletedFalse = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":false,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; - when(property.value()).thenReturn(vertexJsonIsDeletedFalse); - List componentList = toscaOperation.getElementCatalogData(true, null).left().value(); - assertEquals(1, componentList.size()); - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java deleted file mode 100644 index e77f8e108c..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java +++ /dev/null @@ -1,363 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import java.util.*; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -/** - * Created by chaya on 6/12/2017. - */ - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration("classpath:application-context-test.xml") -public class ToscaElementOperationTest extends ModelTestBase{ - - private List allVertices = new ArrayList<>(); - private boolean isInitialized = false; - - @javax.annotation.Resource - private ToscaElementOperationTestImpl toscaElementOperation; - - @javax.annotation.Resource - private TitanDao titanDao; - - @BeforeClass - public static void initTest(){ - ModelTestBase.init(); - - } - - @Rule - public TestName testName = new TestName(); - - @Before - public void beforeTest() { - if (!isInitialized) { - GraphTestUtils.clearGraph(titanDao); - //exportGraphMl(titanDao.getGraph().left().value(),""); - initGraphForTest(); - isInitialized = true; - } - } - - - @Test - public void testGetAllHighestResourcesNoFilter() { - - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, true); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - } - }, null); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - - - - @Test - public void testGetAllResourcesCertifiedNoFilter() { - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, false); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }, null); - highestResourcesExpectedCount += calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }, new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - @Test - public void testGetHighestResourcesExclude() { - - // exclude VFCMT - List excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); - assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); - - // exclude CP & VL - excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); - assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); - - // exclude CP & VL & VF & VFC - excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); - assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); - } - - @Test - public void testGetAllResourcesCertifiedExclude() { - // exclude VFCMT - List excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); - assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); - - // exclude CP & VL - excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); - assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); - - // exclude CP & VL & VF & VFC - excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); - assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); - } - - @Test - public void testGetAllHighestServicesNoFilter() { - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, true); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - } - }, null); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - @Test - public void testGetAllCertifiedServicesNoFilter() { - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, false); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }, null); - highestResourcesExpectedCount += calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }, new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - @Test - public void testGetServicesExcludeList() { - List excludeList = Arrays.asList(ResourceTypeEnum.VF, ResourceTypeEnum.VFCMT); - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, true); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - } - }, null); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - @Test - public void testGetCertifiedServicesExcludeList() { - List excludeList = Arrays.asList(ResourceTypeEnum.VL); - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, false); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }, null); - highestResourcesExpectedCount += calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }, new HashMap() { - { - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }); - assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); - } - - @Test - public void testUpdateToscaElement_NotFound() { - Either result; - TopologyTemplate topologyTemplate = new TopologyTemplate(); - String userID = "userID"; - topologyTemplate.setLastUpdaterUserId(userID); - GraphVertex graphVertex = new GraphVertex(); - ComponentParametersView componentParametersView = new ComponentParametersView(); - result = toscaElementOperation.updateToscaElement(topologyTemplate, graphVertex, componentParametersView); - assertEquals(null, result); - } - - private boolean genericTestGetResourcesWithExcludeList(List excludeList) { - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE,excludeList, true); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - } - }, new HashMap() { - { - put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); - } - }); - return highestResources.stream().count() == (highestResourcesExpectedCount); - } - - private boolean genericTestGetCertifiedResourcesWithExcludeList(List excludeList) { - Either, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludeList, false); - assertTrue(highestResourcesRes.isLeft()); - List highestResources = highestResourcesRes.left().value(); - // calculate expected count value - long highestResourcesExpectedCount = calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }, new HashMap() { - { - put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); - } - }); - highestResourcesExpectedCount += calculateCount(new HashMap() { - { - put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }, new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); - } - }); - return highestResources.stream().count() == highestResourcesExpectedCount; - } - - private void initGraphForTest() { - GraphTestUtils.createRootCatalogVertex(titanDao); - - Map highstVerticesProps = new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - } - }; - - Map certifiedVerticesProps = new HashMap() { - { - put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - } - }; - - // add vertices with higestVersion = true - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VF)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VFC)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VFCMT)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VL)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.CP)); - allVertices.add(GraphTestUtils.createServiceVertex(titanDao, highstVerticesProps)); - - // add vertices with non-additional properties - for (int i=0 ; i<2 ; i++) { - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VF)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VFC)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VFCMT)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VL)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.CP)); - allVertices.add(GraphTestUtils.createServiceVertex(titanDao, new HashMap<>())); - } - - // add certified vertices - for (int i=0; i<3; i++) { - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VF)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VFC)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VFCMT)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VL)); - allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.CP)); - allVertices.add(GraphTestUtils.createServiceVertex(titanDao, certifiedVerticesProps)); - } - //allVertices.stream().forEach( v -> System.out.println("type: "+v.getMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE))); - //String result = GraphTestUtils.exportGraphMl(titanDao.getGraph().left().value(), ""); - //System.out.println("graph is: " + result); - } - - private long calculateCount(HashMap hasProps, Map doesntHaveProps){ - return allVertices.stream(). - filter(v -> { - Map vertexProps = v.getMetadataProperties(); - if (hasProps != null) { - for (Map.Entry prop: hasProps.entrySet()){ - Object value = vertexProps.get(prop.getKey()); - if ( value == null || !value.equals(prop.getValue())) { - return false; - } - } - } - - if (doesntHaveProps != null) { - for (Map.Entry prop : doesntHaveProps.entrySet()) { - Object value = vertexProps.get(prop.getKey()); - Object propValue = prop.getValue(); - if ( value != null && propValue != null && propValue instanceof List ) { - for (ResourceTypeEnum propVal : (List)propValue) { - if (propVal.name().equals(value)) { - return false; - } - } - } - else if (value != null && value.equals(propValue)){ - return false; - } - } - } - return true; - }).count(); - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java deleted file mode 100644 index 27fbce4776..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java +++ /dev/null @@ -1,74 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; - -/** - * Created by cb478c on 6/13/2017. - */ -@org.springframework.stereotype.Component("test-tosca-element-operation") -public class ToscaElementOperationTestImpl extends ToscaElementOperation { - - @Override - protected Either getLightComponent(GraphVertex vertexComponent, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { - titanDao.parseVertexProperties(vertexComponent, JsonParseFlagEnum.ParseMetadata); - T toscaElement = convertToComponent(vertexComponent); - return Either.left(toscaElement); - } - - @Override - public Either getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { - return null; - } - - @Override - public Either getToscaElement(GraphVertex toscaElementVertex, ComponentParametersView componentParametersView) { - return null; - } - - @Override - public Either deleteToscaElement(GraphVertex toscaElementVertex) { - return null; - } - - @Override - public Either createToscaElement(ToscaElement toscaElement) { - return null; - } - - @Override - protected TitanOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { - return null; - } - - @Override - protected TitanOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { - return null; - } - - @Override - protected TitanOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { - return null; - } - - @Override - protected StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { - return null; - } - - @Override - protected StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex updateElementV) { - return null; - } - - @Override - public void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { - - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java deleted file mode 100644 index 95dca7f920..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java +++ /dev/null @@ -1,135 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.config.TitanSpringConfig; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -import static java.util.Arrays.asList; -import static java.util.Collections.singletonList; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertTrue; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) -public class ToscaOperationFacadePoliciesTest extends ModelTestBase { - - @Autowired - private ToscaOperationFacade toscaOperationFacade; - @Autowired - private HealingTitanDao titanDao; - - private PolicyDefinition policy1, policy2; - - @BeforeClass - public static void setupBeforeClass() { - ModelTestBase.init(); - } - - @Before - public void setUp() throws Exception { - policy1 = createPolicyDefinition("type1"); - policy2 = createPolicyDefinition("type2"); - createContainerVertexInDB(); - createPoliciesOnGraph(policy1, policy2); - } - - private void createPoliciesOnGraph(PolicyDefinition ... policies) { - for (int i = 0; i < policies.length; i++) { - PolicyDefinition policy = policies[i]; - Either createdPolicy = toscaOperationFacade.associatePolicyToComponent(CONTAINER_ID, policy, i); - assertTrue(createdPolicy.isLeft()); - } - } - - @After - public void tearDown() { - titanDao.rollback(); - } - - @Test - public void updatePoliciesTargetsOfComponent_updateSinglePolicy() { - List updatedTargetIds = asList("instance1new", "instance2"); - PolicyDefinition originalPolicy2 = clonePolicyWithTargets(policy2); - updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); - updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); - - StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, singletonList(policy1)); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); - Component updatedComponent = fetchComponentFromDB(); - verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); - verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), originalPolicy2); - } - - @Test - public void updatePoliciesTargetsOfComponent_updateMultiplePolicies() { - List updatedTargetIds = asList("instance1new", "instance2"); - updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); - updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); - StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, asList(policy1, policy2)); - assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); - Component updatedComponent = fetchComponentFromDB(); - verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); - verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), policy2); - } - - private PolicyDefinition clonePolicyWithTargets(PolicyDefinition policy) { - PolicyDefinition originalPolicy = new PolicyDefinition(policy); - Map> clonedTargetMap = policy.getTargets().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> new ArrayList<>(entry.getValue()))); - originalPolicy.setTargets(clonedTargetMap); - return originalPolicy; - } - - private void verifyPolicyTargets(PolicyDefinition updatedPolicy, PolicyDefinition expectedPolicy) { - assertThat(updatedPolicy.getTargets()) - .isEqualTo(expectedPolicy.getTargets()); - } - - private void updatePolicyTypeTargetsIds(PolicyDefinition policy, PolicyTargetType targetType, List updatedTargetIds) { - policy.getTargets().put(targetType, updatedTargetIds); - } - - private Component fetchComponentFromDB() { - ComponentParametersView componentParametersView = new ComponentParametersView(); - componentParametersView.disableAll(); - componentParametersView.setIgnorePolicies(false); - return toscaOperationFacade.getToscaElement(CONTAINER_ID, componentParametersView).left().value(); - } - - private void createContainerVertexInDB() { - GraphVertex resource = createBasicContainerGraphVertex(); - Either container = titanDao.createVertex(resource); - assertTrue(container.isLeft()); - } - - private PolicyDefinition createPolicyDefinition(String type) { - PolicyDefinition policy = new PolicyDefinition(); - policy.setPolicyTypeName(type); - policy.setTargets(new HashMap<>()); - policy.getTargets().put(PolicyTargetType.COMPONENT_INSTANCES, asList("instance1", "instance2")); - return policy; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java deleted file mode 100644 index b43b632ad1..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java +++ /dev/null @@ -1,688 +0,0 @@ -/* - - * Copyright (c) 2018 AT&T Intellectual Property. - - * - - * Licensed under the Apache License, Version 2.0 (the "License"); - - * you may not use this file except in compliance with the License. - - * You may obtain a copy of the License at - - * - - * http://www.apache.org/licenses/LICENSE-2.0 - - * - - * Unless required by applicable law or agreed to in writing, software - - * distributed under the License is distributed on an "AS IS" BASIS, - - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - - * See the License for the specific language governing permissions and - - * limitations under the License. - - */ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.ArgumentMatchers; -import org.mockito.MockitoAnnotations; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.HealingTitanDao; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentInstanceProperty; -import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.ComponentParametersView; -import org.openecomp.sdc.be.model.PolicyDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; -import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.DataTypeDefinition; -import org.openecomp.sdc.be.model.PropertyDefinition; -import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.ArrayList; -import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import java.util.Collections; -import java.util.Arrays; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyMap; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; - -@RunWith(MockitoJUnitRunner.class) -public class ToscaOperationFacadeTest { - private static final String COMPONENT_ID = "componentId"; - private static final String PROPERTY1_NAME = "prop1"; - private static final String PROPERTY1_TYPE = "string"; - private static final String PROPERTY2_NAME = "prop2"; - private static final String PROPERTY2_TYPE = "integer"; - - @InjectMocks - private ToscaOperationFacade testInstance; - - @Mock - private HealingTitanDao titanDaoMock; - - @Mock - private TopologyTemplateOperation topologyTemplateOperationMock; - - @Mock - private NodeTypeOperation nodeTypeOperation; - - @Mock - private NodeTemplateOperation nodeTemplateOperationMock; - - @Before - public void setUp() throws Exception { - testInstance = new ToscaOperationFacade(); - MockitoAnnotations.initMocks(this); - } - - @SuppressWarnings("unchecked") - @Test - public void fetchMetaDataByResourceType() throws Exception { - ArgumentCaptor criteriaCapture = ArgumentCaptor.forClass(Map.class); - ArgumentCaptor criteriaNotCapture = ArgumentCaptor.forClass(Map.class); - ComponentParametersView dataFilter = new ComponentParametersView(); - List mockVertices = getMockVertices(2); - Either, TitanOperationStatus> returnedVertices = Either.left(mockVertices); - - when(titanDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices); - when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0"))); - when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1"))); - Either, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter); - - verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture); - verifyCriteriaNotIsDeleted(criteriaNotCapture); - - assertTrue(fetchedComponents.isLeft()); - List cmpts = fetchedComponents.left().value(); - assertEquals(2, cmpts.size()); - assertEquals("0", cmpts.get(0).getUniqueId()); - assertEquals("1", cmpts.get(1).getUniqueId()); - } - - private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor criteriaCapture) { - Map criteria = (Map)criteriaCapture.getValue(); - assertEquals(2, criteria.size()); - assertEquals(criteria.get(GraphPropertyEnum.RESOURCE_TYPE), "VF"); - assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true); - } - - private void verifyCriteriaNotIsDeleted(ArgumentCaptor criteriaNotCapture) { - Map notCriteria = (Map)criteriaNotCapture.getValue(); - assertEquals(1, notCriteria.size()); - assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true); - } - - @SuppressWarnings("unchecked") - @Test - public void fetchMetaDataByResourceType_failedToGetData() throws Exception { - when(titanDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); - Either, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView()); - assertTrue(fetchedComponents.isRight()); - assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value()); - } - - @Test - public void associatePolicyToComponentSuccessTest(){ - Either result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK); - assertTrue(result.isLeft()); - } - - @Test - public void associatePolicyToComponentFailureTest(){ - Either result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); - } - - @Test - public void updatePolicyOfComponentSuccessTest(){ - Either result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK); - assertTrue(result.isLeft()); - } - - @Test - public void updatePolicyOfComponentFailureTest(){ - Either result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); - } - - @Test - public void removePolicyFromComponentSuccessTest(){ - removePolicyFromComponentWithStatus(StorageOperationStatus.OK); - } - - @Test - public void removePolicyFromComponentFailureTest(){ - removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND); - } - - @Test - public void testFindLastCertifiedToscaElementByUUID(){ - Either result; - Component component = new Resource(); - List list = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - list.add(graphVertex); - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.UUID, component.getUUID()); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - ToscaElement toscaElement = getToscaElementForTest(); - when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - when(titanDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list)); - result = testInstance.findLastCertifiedToscaElementByUUID(component); - Component resultComp = result.left().value(); - assertEquals(resultComp.getToscaType(),ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); - } - - @Test - public void testLatestComponentByToscaResourceName(){ - Either result; - TopologyTemplate toscaElement = new TopologyTemplate(); - toscaElement.setComponentType(ComponentTypeEnum.SERVICE); - List list = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - Map props = new HashMap<>(); - props.put(GraphPropertyEnum.VERSION, "1.0"); - graphVertex.setMetadataProperties(props); - list.add(graphVertex); - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName"); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - when(titanDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(list)); - when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - - result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName"); - assertThat(result.isLeft()); - } - - @Test - public void testValidateCsarUuidUniqueness() { - StorageOperationStatus result; - String csarUUID = "csarUUID"; - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); - List vertexList = new ArrayList<>(); - when(titanDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList)); - result = testInstance.validateCsarUuidUniqueness(csarUUID); - assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result); - } - - @Test - public void testValidateCsarUuidUnique_true() { - StorageOperationStatus result; - String csarUUID = "csarUUID"; - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID); - when(titanDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - result = testInstance.validateCsarUuidUniqueness(csarUUID); - assertEquals(StorageOperationStatus.OK, result); - } - - @Test - public void testGetLatestCertiNodeTypeByToscaResourceName() { - Either result; - String toscaResourceName = "resourceName"; - String uniqueId = "uniqueId"; - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0"); - graphVertex.setUniqueId(uniqueId); - List vertexList = new ArrayList<>(); - vertexList.add(graphVertex); - Map props = new EnumMap<>(GraphPropertyEnum.class); - props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); - props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); - ToscaElement topologyTemplate = new TopologyTemplate(); - topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); - when(titanDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList)); - when(titanDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); - when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(topologyTemplate)); - result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName); - assertThat(result.isLeft()); - } - - @Test - public void testValidateCompExists() { - Either result; - String componentId = "componentId"; - GraphVertex graphVertex = getTopologyTemplateVertex(); - when(titanDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); - result = testInstance.validateComponentExists(componentId); - assertEquals(true, result.left().value()); - } - - @Test - public void testValidateCompExists_NotFound() { - Either result; - String componentId = "componentId"; - when(titanDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - result = testInstance.validateComponentExists(componentId); - assertEquals(false, result.left().value()); - } - - @Test - public void testValidateToscaResourceNameExists() { - Either result; - String templateName = "templateName"; - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName); - List graphVertexList = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertexList.add(graphVertex); - when(titanDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList)); - result = testInstance.validateToscaResourceNameExists(templateName); - assertEquals(true, result.left().value()); - } - - @Test - public void testValidateToscaResourceNameExists_false() { - Either result; - String templateName = "templateName"; - Map properties = new EnumMap<>(GraphPropertyEnum.class); - properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName); - List graphVertexList = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertexList.add(graphVertex); - when(titanDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - result = testInstance.validateToscaResourceNameExists(templateName); - assertEquals(false, result.left().value()); - } - - @Test - public void testOverrideComponent() { - Either result; - Resource resource = new Resource(); - String id = "id"; - resource.setUniqueId(id); - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); - NodeType nodeType = new NodeType(); - nodeType.setComponentType(ComponentTypeEnum.RESOURCE); - ToscaElement toscaElement = new TopologyTemplate(); - toscaElement.setComponentType(ComponentTypeEnum.SERVICE); - when(titanDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); - when(titanDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); - when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement)); - when(nodeTypeOperation.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType)); - when(titanDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex)); - when(titanDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(TitanOperationStatus.OK); - result = testInstance.overrideComponent(resource, resource); - assertTrue(result.isLeft()); - } - - @Test - public void testGetToscaElement() { - Either result; - String id = "id"; - GraphVertex graphVertex = getTopologyTemplateVertex(); - ToscaElement toscaElement = getToscaElementForTest(); - when(titanDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); - when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll); - assertTrue(result.isLeft()); - } - - @Test - public void testMarkComponentToDelete() { - StorageOperationStatus result; - Component component = new Resource(); - String id = "id"; - component.setUniqueId(id); - GraphVertex graphVertex = getTopologyTemplateVertex(); - when(titanDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); - when(nodeTypeOperation.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex)); - result = testInstance.markComponentToDelete(component); - assertEquals(result, StorageOperationStatus.OK); - } - - @Test - public void testDelToscaComponent() { - Either result; - String componentId = "compId"; - GraphVertex graphVertex = getTopologyTemplateVertex(); - ToscaElement toscaElement = getToscaElementForTest(); - when(titanDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex)); - when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement)); - result = testInstance.deleteToscaComponent(componentId); - assertTrue(result.isLeft()); - } - - @Test - public void testGetLatestByToscaResourceName() { - Either result; - String toscaResourceName = "name"; - ToscaElement toscaElement = getToscaElementForTest(); - - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName); - propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - List graphVertexList = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertex.setUniqueId(toscaResourceName); - Map props = new HashMap<>(); - props.put(GraphPropertyEnum.VERSION, "1.0"); - graphVertex.setMetadataProperties(props); - graphVertexList.add(graphVertex); - - when(titanDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList)); - when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - result = testInstance.getLatestByToscaResourceName(toscaResourceName); - assertTrue(result.isLeft()); - } - - @Test - public void testGetFollowed() { - Either, StorageOperationStatus> result; - String userId = "id"; - Set lifecycleStates = new HashSet<>(); - Set lastStateStates = new HashSet<>(); - lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); - lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - lifecycleStates.add(LifecycleStateEnum.READY_FOR_CERTIFICATION); - lifecycleStates.add(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); - lifecycleStates.add(LifecycleStateEnum.CERTIFIED); - lastStateStates.add(LifecycleStateEnum.READY_FOR_CERTIFICATION); - ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE; - List toscaEleList = new ArrayList<>(); - ToscaElement toscaElement = getToscaElementForTest(); - toscaEleList.add(toscaElement); - when(nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType)).thenReturn(Either.left(toscaEleList)); - result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType); - assertTrue(result.isLeft()); - assertEquals(1, result.left().value().size()); - } - - @Test - public void testGetBySystemName() { - Either, StorageOperationStatus> result; - String sysName = "sysName"; - ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; - ToscaElement toscaElement = getToscaElementForTest(); - List componentVertices = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - componentVertices.add(graphVertex); - Map propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class); - Map propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class); - - propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName); - propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name()); - - propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true); - - when(titanDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertices)); - when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - result = testInstance.getBySystemName(componentTypeEnum, sysName); - assertTrue(result.isLeft()); - assertEquals(1, result.left().value().size()); - } - - @Test - public void testGetCompByNameAndVersion() { - Either result; - ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE; - String name = "name"; - String version = "1.0"; - JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll; - List graphVertexList = new ArrayList<>(); - GraphVertex graphVertex = getTopologyTemplateVertex(); - graphVertexList.add(graphVertex); - ToscaElement toscaElement = getToscaElementForTest(); - Map hasProperties = new EnumMap<>(GraphPropertyEnum.class); - Map hasNotProperties = new EnumMap<>(GraphPropertyEnum.class); - - hasProperties.put(GraphPropertyEnum.NAME, name); - hasProperties.put(GraphPropertyEnum.VERSION, version); - hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true); - hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name()); - when(titanDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList)); - when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement)); - result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag); - assertTrue(result.isLeft()); - } - - private ToscaElement getToscaElementForTest() { - ToscaElement toscaElement = new TopologyTemplate(); - toscaElement.setComponentType(ComponentTypeEnum.RESOURCE); - return toscaElement; - } - - @Test - public void addDataTypesToComponentSuccessTest(){ - Either, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK); - assertTrue(result.isLeft()); - } - - @Test - public void addDataTypesToComponentFailureTest_BadRequest(){ - Either, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); - } - - private Either, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) { - Map dataTypes = new HashMap<>(); - String componentId = "componentid"; - String Id = "id"; - - PropertyDefinition noDefaultProp = new PropertyDefinition(); - noDefaultProp.setName("noDefaultProp"); - PropertyDefinition prop1 = new PropertyDefinition(); - prop1.setDefaultValue("def1"); - prop1.setName("prop1"); - PropertyDefinition prop2 = new PropertyDefinition(); - prop2.setType("dataType1"); - prop2.setName("prop2"); - PropertyDefinition prop3 = new PropertyDefinition(); - prop3.setDefaultValue("def3"); - prop3.setName("prop3"); - - DataTypeDefinition noDefaultValue = new DataTypeDefinition(); - noDefaultValue.setProperties(Collections.singletonList(noDefaultProp)); - noDefaultValue.setDerivedFromName("name0"); - - DataTypeDefinition dataType1 = new DataTypeDefinition(); - dataType1.setProperties(Arrays.asList(prop1, prop3)); - dataType1.setName("name1"); - dataType1.setDerivedFromName("derivedfromname1"); - - DataTypeDefinition dataType2 = new DataTypeDefinition(); - dataType2.setDerivedFrom(dataType1); - dataType2.setName("name2"); - dataType2.setDerivedFromName("derivedfromname2"); - - DataTypeDefinition dataType3 = new DataTypeDefinition(); - dataType3.setProperties(Collections.singletonList(prop2)); - dataType3.setDerivedFrom(noDefaultValue); - dataType3.setName("name3"); - dataType3.setDerivedFromName("derivedfromname3"); - - dataTypes.put("noDefault", noDefaultValue); - dataTypes.put("dataType1", dataType1); - dataTypes.put("dataType2", dataType2); - dataTypes.put("dataType3", dataType3); - - GraphVertex vertex; - if(status == StorageOperationStatus.OK){ - vertex = getTopologyTemplateVertex(); - } else { - vertex = getNodeTypeVertex(); - } - Either getVertexEither = Either.left(vertex); - when(titanDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither); - when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex), - eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status); - return testInstance.addDataTypesToComponent(dataTypes, componentId); - } - - @Test - public void testDataTypesToComponentFailureTest_NotFound() { - Either, StorageOperationStatus> result; - String componentId = "componentId"; - GraphVertex vertex = getNodeTypeVertex(); - Map dataTypes = new HashMap<>(); - when(titanDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - result = testInstance.addDataTypesToComponent(dataTypes, componentId); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); - } - - @Test - public void testDeleteDataTypeOfComponent() { - StorageOperationStatus result; - Component component = new Resource(); - String id = "id"; - component.setUniqueId(id); - String datatype = null; - - DataTypeDefinition dataType1 = new DataTypeDefinition(); - dataType1.setName("name1"); - Map dataTypeDataMap = new HashMap<>(); - dataTypeDataMap.put("datatype1", dataType1); - List dataTypeMap = dataTypeDataMap.values().stream().map(e -> { DataTypeDefinition dataType = new DataTypeDefinition(e);return dataType; }).collect(Collectors.toList()); - component.setDataTypes(dataTypeMap); - GraphVertex graphVertex = getTopologyTemplateVertex(); - result = testInstance.deleteDataTypeOfComponent(component, "datatype1"); - assertEquals(datatype, result); - } - - @Test - public void testAddComponentInstancePropertiesToComponent() { - // set up component object - Component component = new Resource(); - component.setUniqueId(COMPONENT_ID); - List instanceProps = new ArrayList<>(); - ComponentInstanceProperty instanceProp = new ComponentInstanceProperty(); - instanceProp.setName(PROPERTY1_NAME); - instanceProp.setType(PROPERTY1_TYPE); - instanceProps.add(instanceProp); - instanceProp = new ComponentInstanceProperty(); - instanceProp.setName(PROPERTY2_NAME); - instanceProp.setType(PROPERTY2_TYPE); - instanceProps.add(instanceProp); - Map> instancePropsMap = - Collections.singletonMap(COMPONENT_ID, instanceProps); - component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>())); - - when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any())) - .thenReturn(StorageOperationStatus.OK); - - Either>, StorageOperationStatus> result = - testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap); - assertTrue(result.isLeft()); - verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any()); - List resultProps = result.left().value().get(COMPONENT_ID); - assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME))); - assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME))); - } - - private Either associatePolicyToComponentWithStatus(StorageOperationStatus status) { - PolicyDefinition policy = new PolicyDefinition(); - String componentId = "componentId"; - int counter = 0; - GraphVertex vertex; - if(status == StorageOperationStatus.OK){ - vertex = getTopologyTemplateVertex(); - } else { - vertex = getNodeTypeVertex(); - } - Either getVertexEither = Either.left(vertex); - when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither); - when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status); - return testInstance.associatePolicyToComponent(componentId, policy, counter); - } - - private Either updatePolicyOfComponentWithStatus(StorageOperationStatus status) { - PolicyDefinition policy = new PolicyDefinition(); - String componentId = "componentId"; - GraphVertex vertex = getTopologyTemplateVertex(); - when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex)); - when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status); - return testInstance.updatePolicyOfComponent(componentId, policy); - } - - private void removePolicyFromComponentWithStatus(StorageOperationStatus status) { - String componentId = "componentId"; - String policyId = "policyId"; - GraphVertex vertex = getTopologyTemplateVertex(); - Either getVertexEither = Either.left(vertex); - when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither); - when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status); - StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId); - assertSame(result, status); - } - - private List getMockVertices(int numOfVertices) { - return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList()); - } - - private ToscaElement getResourceToscaElement(String id) { - ToscaElement toscaElement = new TopologyTemplate(); - toscaElement.setMetadata(new HashMap<>()); - toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE"); - toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id); - return toscaElement; - } - - private GraphVertex getTopologyTemplateVertex() { - GraphVertex graphVertex = new GraphVertex(); - graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); - return graphVertex; - } - - private GraphVertex getNodeTypeVertex() { - GraphVertex graphVertex = new GraphVertex(); - graphVertex.setLabel(VertexTypeEnum.NODE_TYPE); - return graphVertex; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java deleted file mode 100644 index acb9af6a33..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java +++ /dev/null @@ -1,183 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import fj.data.Either; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; -import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.*; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; -import org.openecomp.sdc.be.model.operations.api.IElementOperation; -import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; - -import javax.annotation.Resource; -import java.util.ArrayList; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration("classpath:application-context-test.xml") -public class UpgradeOperationTest extends ModelTestBase { - - private boolean isInitialized; - @Resource - private TitanDao titanDao; - @Resource - private UpgradeOperation upgradeOperation; - @Resource - private TopologyTemplateOperation topologyTemplateOperation; - @Resource - private NodeTemplateOperation nodeTemplateOperation; - @Resource - private UserAdminOperation userAdminOperation; - @javax.annotation.Resource - private IElementOperation elementOperation; - - private User user; - - private CategoryDefinition resourceCategory; - private CategoryDefinition serviceCategory; - - - @BeforeClass - public static void initTest() { - ModelTestBase.init(); - } - - @Before - public void beforeTest() { - if (!isInitialized) { - GraphTestUtils.clearGraph(titanDao); - initGraphForTest(); - isInitialized = true; - } - } - - @Test - public void testGetSimpleDependency() { - - TopologyTemplate vf = createVf("vf1"); - - TopologyTemplate service = createServiceWitnInstance("service1", vf); - - - Either, StorageOperationStatus> result = upgradeOperation.getComponentDependencies(vf.getUniqueId()); - assertThat(result.isLeft()).isTrue(); - List dependencies = result.left().value(); - assertThat(dependencies).hasSize(1); - - ComponentDependency dependency = dependencies.get(0); - assertThat(dependency.getName()).isEqualTo(vf.getName()); - assertThat(dependency.getVersion()).isEqualTo(vf.getVersion()); - assertThat(dependency.getDependencies()).hasSize(1); - - ComponentDependency container = dependency.getDependencies().get(0); - assertThat(container.getName()).isEqualTo(service.getName()); - assertThat(container.getVersion()).isEqualTo(service.getVersion()); - assertThat(container.getDependencies()).isNull(); - - } - - /******************************* - * Preperation Methods - *******************************/ - private void initGraphForTest() { - - user = new User("Jim", "Tom", "jt123a", "1@mail.com", "DESIGNER", System.currentTimeMillis()); - Either saveUserData = userAdminOperation.saveUserData(user); - assertThat(saveUserData.isLeft()).isTrue(); - - GraphTestUtils.createRootCatalogVertex(titanDao); - resourceCategory = createResourceCategories(); - serviceCategory = createServiceCategory(); - - } - - private TopologyTemplate createServiceWitnInstance(String name, TopologyTemplate createdVf) { - - TopologyTemplate serviceNew = createTopologyTemplate(ComponentTypeEnum.SERVICE, name); - List categoriesService = new ArrayList<>(); - categoriesService.add(serviceCategory); - serviceNew.setCategories(categoriesService); - - Either createService = topologyTemplateOperation.createTopologyTemplate(serviceNew); - assertThat(createService.isLeft()).isTrue(); - - ComponentInstance vfInstance = new ComponentInstance(); - vfInstance.setUniqueId(createdVf.getUniqueId() + createdVf.getName()); - vfInstance.setComponentUid(createdVf.getUniqueId()); - vfInstance.setName(createdVf.getName()); - Either, StorageOperationStatus> addInstance = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(serviceNew, createdVf, "0", vfInstance, false, user); - assertThat(addInstance.isLeft()).isTrue(); - return serviceNew; - } - - private CategoryDefinition createServiceCategory() { - CategoryDefinition categoryService = new CategoryDefinition(); - categoryService.setName("servicecategory"); - categoryService.setNormalizedName("servicecategory"); - categoryService.setUniqueId("servicecategory"); - Either createCategory = elementOperation.createCategory(categoryService , NodeTypeEnum.ServiceNewCategory); - - assertThat(createCategory.isLeft()).isTrue(); - return categoryService; - } - - private TopologyTemplate createVf(String name) { - - TopologyTemplate resource = createTopologyTemplate(ComponentTypeEnum.RESOURCE, name); - - resource.setResourceType(ResourceTypeEnum.VF); - List categories = new ArrayList<>(); - categories.add(resourceCategory); - resource.setCategories(categories); - Either createVf = topologyTemplateOperation.createTopologyTemplate(resource); - assertThat( createVf.isLeft()).isTrue(); - return resource; - } - - private CategoryDefinition createResourceCategories() { - CategoryDefinition category = new CategoryDefinition(); - category.setName("category1"); - category.setNormalizedName("category1"); - category.setUniqueId("category1"); - Either createCategory = elementOperation.createCategory(category , NodeTypeEnum.ResourceNewCategory); - assertThat(createCategory.isLeft()).isTrue(); - - SubCategoryDefinition subCategory = new SubCategoryDefinition(); - - subCategory.setName("subcategory1"); - subCategory.setNormalizedName("subcategory1"); - subCategory.setUniqueId("subcategory1"); - elementOperation.createSubCategory(createCategory.left().value().getUniqueId(), subCategory, NodeTypeEnum.ResourceSubcategory); - category.addSubCategory(subCategory); - return category; - } - - private TopologyTemplate createTopologyTemplate(ComponentTypeEnum type, String name) { - TopologyTemplate template = new TopologyTemplate(); - template.setUniqueId(IdBuilderUtils.generateUniqueId()); - template.setComponentType(type); - template.setHighestVersion(true); - template.setLifecycleState(LifecycleStateEnum.CERTIFIED); - template.setMetadataValue(JsonPresentationFields.NAME, name); - template.setMetadataValue(JsonPresentationFields.VERSION, "1.0"); - template.setCreatorUserId(user.getUserId()); - return template; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityTestUtils.java deleted file mode 100644 index 6f6b7eacad..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/CapabilityTestUtils.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.model.jsontitan.utils; - -import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; -import org.openecomp.sdc.be.model.CapabilityDefinition; -import org.openecomp.sdc.be.model.ComponentInstanceProperty; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -public class CapabilityTestUtils { - - public static Map createCapPropsForTopologyTemplate(TopologyTemplate topologyTemplate) { - Map capabilitiesMap = new HashMap<>(); - - List capabilityDefinitions = new ArrayList<>(); - CapabilityDefinition capabilityDefinition = createCapabilityDefinition(); - - capabilityDefinitions.add(capabilityDefinition); - ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capabilityDefinitions); - capabilitiesMap.put(capabilityDefinition.getType(), listCapabilityDataDefinition); - topologyTemplate.setCapabilities(capabilitiesMap); - - List capPropList = new ArrayList<>(); - ComponentInstanceProperty instanceProperty = createProperties(); - capPropList.add(instanceProperty); - - MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - for (ComponentInstanceProperty cip : capPropList) { - PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip); - dataToCreate.put(cip.getName(), propertyDataDefinition); - } - - Map capabilitiesProperties = new HashMap<>(); - capabilitiesProperties.put(capabilityDefinition.getType() + ModelConverter.CAP_PROP_DELIM + - capabilityDefinition.getName(), dataToCreate); - return capabilitiesProperties; - } - - private static CapabilityDefinition createCapabilityDefinition() { - CapabilityDefinition capabilityDefinition = new CapabilityDefinition(); - capabilityDefinition.setName("cap" + Math.random()); - capabilityDefinition.setType("tosca.capabilities.network.Bindable"); - capabilityDefinition.setOwnerId("resourceId"); - capabilityDefinition.setUniqueId("capUniqueId"); - List path = new ArrayList<>(); - path.add("path1"); - capabilityDefinition.setPath(path); - return capabilityDefinition; - } - - private static ComponentInstanceProperty createProperties() { - ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty(); - instanceProperty.setUniqueId("ComponentInput1_uniqueId"); - instanceProperty.setType("Integer"); - instanceProperty.setName("prop_name"); - instanceProperty.setDescription("prop_description_prop_desc"); - instanceProperty.setOwnerId("capUniqueId"); - instanceProperty.setValue("{\"get_input\":\"extcp20_order\"}"); - instanceProperty.setSchema(new SchemaDefinition()); - return instanceProperty; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java deleted file mode 100644 index 71dd472a1c..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java +++ /dev/null @@ -1,129 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.model.jsontitan.utils; - -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.io.IoCore; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; - -import java.io.BufferedOutputStream; -import java.io.File; -import java.io.FileOutputStream; -import java.io.OutputStream; -import java.util.Iterator; -import java.util.Map; -import java.util.UUID; - -public final class GraphTestUtils { - - public static GraphVertex createRootCatalogVertex(TitanDao titanDao) { - GraphVertex catalogRootVertex = new GraphVertex(VertexTypeEnum.CATALOG_ROOT); - catalogRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); - return titanDao.createVertex(catalogRootVertex) - .either(v -> v, s -> null); - } - - public static GraphVertex createRootArchiveVertex(TitanDao titanDao) { - GraphVertex archiveRootVertex = new GraphVertex(VertexTypeEnum.ARCHIVE_ROOT); - archiveRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); - return titanDao.createVertex(archiveRootVertex) - .either(v -> v, s -> null); - } - - public static GraphVertex createResourceVertex(TitanDao titanDao, Map metadataProps, ResourceTypeEnum type) { - GraphVertex vertex = new GraphVertex(); - if (type == ResourceTypeEnum.VF) { - vertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); - vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); - } else { - vertex.setLabel(VertexTypeEnum.NODE_TYPE); - vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.NODE_TYPE); - } - String uuid = UUID.randomUUID().toString(); - vertex.setUniqueId(uuid); - - vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); - vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); - vertex.addMetadataProperty(GraphPropertyEnum.RESOURCE_TYPE, type.name()); - vertex.addMetadataProperty(GraphPropertyEnum.IS_ABSTRACT, false); - for (Map.Entry prop : metadataProps.entrySet()) { - vertex.addMetadataProperty(prop.getKey(), prop.getValue()); - } - titanDao.createVertex(vertex); - titanDao.commit(); - return vertex; - } - - public static GraphVertex createServiceVertex(TitanDao titanDao, Map metadataProps){ - GraphVertex vertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); - String uuid = UUID.randomUUID().toString(); - vertex.setUniqueId(uuid); - vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); - vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); - vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); - for (Map.Entry prop : metadataProps.entrySet()) { - vertex.addMetadataProperty(prop.getKey(), prop.getValue()); - } - titanDao.createVertex(vertex); - titanDao.commit(); - return vertex; - } - - public static void clearGraph(TitanDao titanDao) { - Either graphResult = titanDao.getGraph(); - TitanGraph graph = graphResult.left().value(); - - Iterable vertices = graph.query().vertices(); - if (vertices != null) { - Iterator iterator = vertices.iterator(); - while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); - vertex.remove(); - } - } - titanDao.commit(); - } - - public static String exportGraphMl(TitanGraph graph, String outputDirectory) { - String result = null; - String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml"; - try { - try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) { - graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph); - } - result = outputFile; - graph.tx().commit(); - } catch (Exception e) { - graph.tx().rollback(); - e.printStackTrace(); - } - return result; - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapperTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapperTest.java deleted file mode 100644 index 39ea68c3fe..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/IdMapperTest.java +++ /dev/null @@ -1,37 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.utils; - -import org.junit.Test; -import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; - -public class IdMapperTest { - - private IdMapper createTestSubject() { - return new IdMapper(); - } - - - @Test - public void testMapComponentNameToUniqueId() throws Exception { - IdMapper testSubject; - String componentInstanceName = ""; - GraphVertex serviceVertex = null; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.mapComponentNameToUniqueId(componentInstanceName, serviceVertex); - } - - - @Test - public void testMapUniqueIdToComponentNameTo() throws Exception { - IdMapper testSubject; - String compUniqueId = ""; - GraphVertex serviceVertex = null; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.mapUniqueIdToComponentNameTo(compUniqueId, serviceVertex); - } -} \ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverterTest.java deleted file mode 100644 index a927f5a461..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverterTest.java +++ /dev/null @@ -1,137 +0,0 @@ -/* - - * Copyright (c) 2018 Huawei Intellectual Property. - - * - - * Licensed under the Apache License, Version 2.0 (the "License"); - - * you may not use this file except in compliance with the License. - - * You may obtain a copy of the License at - - * - - * http://www.apache.org/licenses/LICENSE-2.0 - - * - - * Unless required by applicable law or agreed to in writing, software - - * distributed under the License is distributed on an "AS IS" BASIS, - - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - - * See the License for the specific language governing permissions and - - * limitations under the License. - - */ -package org.openecomp.sdc.be.model.jsontitan.utils; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.junit.MockitoJUnitRunner; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; -import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum; - -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; - -@RunWith(MockitoJUnitRunner.class) -public class ModelConverterTest { - @InjectMocks - private ModelConverter test; - - @Test - public void testConvertToToscaElementService() - { - Service service = new Service(); - service.setComponentType(ComponentTypeEnum.SERVICE); - TopologyTemplate template = test.convertToToscaElement(service); - assertThat(template.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE); - } - - @Test - public void testConvertToToscaElementResource() - { - Resource resource = new Resource(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - NodeType nodeType = test.convertToToscaElement(resource); - assertThat(nodeType.getToscaType()).isEqualTo(ToscaElementTypeEnum.NODE_TYPE); - } - - @Test - public void testConvertFromToscaElementService() - { - TopologyTemplate topologyTemplate = new TopologyTemplate(); - topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); - Component component = test.convertFromToscaElement(topologyTemplate); - assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); - } - - @Test - public void testConvertFromToscaElementServiceWithSelfCapabilities() - { - TopologyTemplate topologyTemplate = new TopologyTemplate(); - - Map capabilitiesProperties = CapabilityTestUtils - .createCapPropsForTopologyTemplate(topologyTemplate); - - topologyTemplate.setCapabilitiesProperties(capabilitiesProperties); - - topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE); - Component component = test.convertFromToscaElement(topologyTemplate); - assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); - } - - @Test - public void testConvertFromToscaElementResource() - { - TopologyTemplate topologyTemplate = new TopologyTemplate(); - topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE); - Component component = test.convertFromToscaElement(topologyTemplate); - assertThat(component.getToscaType()).isEqualTo(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue()); - } - - @Test - public void testConvertFromToscaElementResourceType() - { - TopologyTemplate topologyTemplate = new TopologyTemplate(); - topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE); - topologyTemplate.setResourceType(ResourceTypeEnum.PNF); - Resource resource = test.convertFromToscaElement(topologyTemplate); - assertSame(ResourceTypeEnum.PNF, resource.getResourceType()); - } - - @Test - public void testIsAtomicComponent() - { - Resource component = new Resource(); - component.setComponentType(ComponentTypeEnum.RESOURCE); - boolean result = test.isAtomicComponent(component); - assertTrue(result); - } - - @Test - public void testGetVertexType() - { - VertexTypeEnum result; - Resource component = new Resource(); - component.setComponentType(ComponentTypeEnum.RESOURCE); - result = test.getVertexType(component); - assertThat(result.getName()).isEqualTo("node_type"); - } -} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java index 6fd04c18bb..dedf84cd76 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java @@ -20,9 +20,9 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanEdge; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphEdge; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import static org.assertj.core.api.Assertions.assertThat; @@ -31,10 +31,10 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.AdditionalInformationDefinition; import org.openecomp.sdc.be.model.ModelTestBase; @@ -55,14 +55,14 @@ import static org.mockito.Mockito.when; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:application-context-test.xml") public class AdditionalInformationOperationTest extends ModelTestBase { - private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class); + private static final JanusGraphGenericDao JANUS_GRAPH_GENERIC_DAO = mock(JanusGraphGenericDao.class); private static String USER_ID = "muUserId"; private static String CATEGORY_NAME = "category/mycategory"; @Mock - private TitanVertex titanVertex; + private JanusGraphVertex janusGraphVertex; - @javax.annotation.Resource(name = "titan-generic-dao") - private TitanGenericDao titanDao; + @javax.annotation.Resource(name = "janusgraph-generic-dao") + private JanusGraphGenericDao janusGraphDao; @javax.annotation.Resource(name = "additional-information-operation") private IAdditionalInformationOperation additionalInformationOperation; @@ -90,10 +90,10 @@ public class AdditionalInformationOperationTest extends ModelTestBase { @Test public void testAddInfoParameter_InvalidId(){ - Either result; + Either result; String uid = "uid"; String componentId = "componentId"; - when(titanGenericDao.getVertexByProperty(eq(uid),eq(componentId))).thenReturn(Either.left(titanVertex)); + when(JANUS_GRAPH_GENERIC_DAO.getVertexByProperty(eq(uid),eq(componentId))).thenReturn(Either.left(janusGraphVertex)); result = additionalInformationOperation.addAdditionalInformationParameter (NodeTypeEnum.Resource,componentId,"key","value"); assertThat(result.isRight()); @@ -101,10 +101,10 @@ public class AdditionalInformationOperationTest extends ModelTestBase { @Test public void testUpdateInfoParameter_InvalidId(){ - Either result; + Either result; String uid = "uid"; String componentId = "componentId"; - when(titanGenericDao.getVertexByProperty(eq(uid),eq(componentId))).thenReturn(Either.left(titanVertex)); + when(JANUS_GRAPH_GENERIC_DAO.getVertexByProperty(eq(uid),eq(componentId))).thenReturn(Either.left(janusGraphVertex)); result = additionalInformationOperation.updateAdditionalInformationParameter (NodeTypeEnum.Resource,componentId,"id","key","value"); assertTrue(result.isRight()); @@ -112,17 +112,17 @@ public class AdditionalInformationOperationTest extends ModelTestBase { @Test public void testDelAdditionalInfoParam_InvalidId() { - Either result; + Either result; String id = "uid"; String componentId = "componentId"; - TitanGraph graph = titanDao.getGraph().left().value(); - TitanVertex v1 = graph.addVertex(); + JanusGraph graph = janusGraphDao.getGraph().left().value(); + JanusGraphVertex v1 = graph.addVertex(); v1.property("uid", componentId); v1.property(GraphPropertiesDictionary.LABEL.getProperty(), "resource"); - TitanVertex v2 = graph.addVertex(); + JanusGraphVertex v2 = graph.addVertex(); v2.property(id,id); - TitanEdge addEdge = v1.addEdge(GraphEdgeLabels.ADDITIONAL_INFORMATION.getProperty(), v2); + JanusGraphEdge addEdge = v1.addEdge(GraphEdgeLabels.ADDITIONAL_INFORMATION.getProperty(), v2); addEdge.property("edgeProp", "resource"); graph.tx().commit(); @@ -132,18 +132,18 @@ public class AdditionalInformationOperationTest extends ModelTestBase { } private void clearGraph() { - Either graphResult = titanDao.getGraph(); - TitanGraph graph = graphResult.left().value(); + Either graphResult = janusGraphDao.getGraph(); + JanusGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } } - titanDao.commit(); + janusGraphDao.commit(); } private UserData deleteAndCreateUser(String userId, String firstName, String lastName) { @@ -152,16 +152,16 @@ public class AdditionalInformationOperationTest extends ModelTestBase { userData.setFirstName(firstName); userData.setLastName(lastName); - titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); - titanDao.createNode(userData, UserData.class); - titanDao.commit(); + janusGraphDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); + janusGraphDao.createNode(userData, UserData.class); + janusGraphDao.commit(); return userData; } private void deleteAndCreateCategory(String category) { String[] names = category.split("/"); - OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao); + OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphDao); } } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AnnotationTypeOperationsTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AnnotationTypeOperationsTest.java index 9a3c66689e..24a263a89b 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AnnotationTypeOperationsTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AnnotationTypeOperationsTest.java @@ -5,7 +5,7 @@ import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.model.AnnotationTypeDefinition; import org.openecomp.sdc.be.model.ModelTestBase; import org.openecomp.sdc.be.model.PropertyDefinition; @@ -29,7 +29,7 @@ public class AnnotationTypeOperationsTest extends ModelTestBase { static final String NEW_DESCRIPTION = "new description"; @Resource - private TitanGenericDao titanGenericDao; + private JanusGraphGenericDao janusGraphGenericDao; @Resource private CommonTypeOperations commonTypeOperations; @@ -47,13 +47,13 @@ public class AnnotationTypeOperationsTest extends ModelTestBase { @Before public void initTestData() { - removeGraphVertices(titanGenericDao.getGraph()); + removeGraphVertices(janusGraphGenericDao.getGraph()); prop1 = createSimpleProperty("val1", "prop1", "string"); } @After public void tearDown() { - titanGenericDao.rollback(); + janusGraphGenericDao.rollback(); } @SuppressWarnings("unchecked") @@ -86,7 +86,7 @@ public class AnnotationTypeOperationsTest extends ModelTestBase { public void addAnnotationType() { prepareInitialType(); annotationTypeOperations.addType(initialAnnotationDefinition); - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } @Test diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java index 8e92549f4f..10553a0f89 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java @@ -23,18 +23,17 @@ package org.openecomp.sdc.be.model.operations.impl; import fj.data.Either; import org.junit.Before; import org.junit.BeforeClass; -import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.*; import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil; import org.openecomp.sdc.be.resources.data.*; @@ -60,8 +59,8 @@ public class ArtifactOperationTest extends ModelTestBase { private static final String ARTIFACT_NAME = "myHeatArtifact"; - @javax.annotation.Resource(name = "titan-generic-dao") - private TitanGenericDao titanDao; + @javax.annotation.Resource(name = "janusgraph-generic-dao") + private JanusGraphGenericDao janusGraphDao; @javax.annotation.Resource(name = "tosca-operation-facade") private ToscaOperationFacade toscaOperationFacade; @@ -99,20 +98,20 @@ public class ArtifactOperationTest extends ModelTestBase { assertEquals(1, heatParameters.size()); HeatParameterDefinition parameter = heatParameters.get(0); HeatParameterData parameterData = new HeatParameterData(parameter); - Either parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNode.isLeft()); Either removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false); assertTrue(removeArifact.isLeft()); ArtifactData artifactData = new ArtifactData(artifactWithHeat); - Either artifactAfterDelete = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + Either artifactAfterDelete = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); assertTrue(artifactAfterDelete.isRight()); - Either parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isRight()); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); } @Test @@ -125,7 +124,7 @@ public class ArtifactOperationTest extends ModelTestBase { assertEquals(1, heatParameters.size()); HeatParameterDefinition parameter = heatParameters.get(0); HeatParameterData parameterData = new HeatParameterData(parameter); - Either parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNode.isLeft()); // update to artifact without params @@ -139,18 +138,18 @@ public class ArtifactOperationTest extends ModelTestBase { assertTrue(updateArifact.isLeft()); ArtifactData artifactData = new ArtifactData(artifactWithHeat); - Either artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + Either artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); assertTrue(artifactAfterUpdate.isLeft()); ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value(); assertEquals(artifactNoParams.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition() .getArtifactVersion()); - Either parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isRight()); artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); } @Test @@ -163,7 +162,7 @@ public class ArtifactOperationTest extends ModelTestBase { assertEquals(1, heatParameters.size()); HeatParameterDefinition parameter = heatParameters.get(0); HeatParameterData parameterData = new HeatParameterData(parameter); - Either parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNode.isLeft()); // update to artifact without params @@ -175,19 +174,19 @@ public class ArtifactOperationTest extends ModelTestBase { assertTrue(updateArifact.isLeft()); ArtifactData artifactData = new ArtifactData(artifactWithHeat); - Either artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + Either artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); assertTrue(artifactAfterUpdate.isLeft()); ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value(); assertEquals(artifactWithHeat.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition() .getArtifactVersion()); - Either parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isLeft()); Either removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, (String) artifactAfterUpdateValue.getUniqueId(), NodeTypeEnum.Resource, true, false); removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); } @@ -198,7 +197,7 @@ public class ArtifactOperationTest extends ModelTestBase { ResourceMetadataData resource2 = createResource(RESOURCE_ID_2); Map props = new HashMap<>(); props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name()); - Either createRelation = titanDao.createRelation(resource2, new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props); + Either createRelation = janusGraphDao.createRelation(resource2, new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props); assertTrue(createRelation.isLeft()); List heatParameters = artifactWithHeat.getListHeatParameters(); @@ -206,7 +205,7 @@ public class ArtifactOperationTest extends ModelTestBase { assertEquals(1, heatParameters.size()); HeatParameterDefinition parameter = heatParameters.get(0); HeatParameterData parameterData = new HeatParameterData(parameter); - Either parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNode.isLeft()); ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat); @@ -227,19 +226,19 @@ public class ArtifactOperationTest extends ModelTestBase { // verify old artifact and parameter still exist ArtifactData artifactData = new ArtifactData(artifactWithHeat); - Either origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + Either origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); assertTrue(origArtifact.isLeft()); ArtifactData origArtifactData = origArtifact.left().value(); assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition() .getArtifactVersion()); - Either parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + Either parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isLeft()); // verify new artifact and new parameter ArtifactDefinition artifactDefinitionUpdated = updateArifact.left().value(); ArtifactData artifactDataUpdated = new ArtifactData(artifactDefinitionUpdated); - Either updatedArtifact = titanDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class); + Either updatedArtifact = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class); assertTrue(updatedArtifact.isLeft()); ArtifactData updatedArtifactData = updatedArtifact.left().value(); assertEquals(atifactToUpdate.getArtifactVersion(), updatedArtifactData.getArtifactDataDefinition() @@ -251,7 +250,7 @@ public class ArtifactOperationTest extends ModelTestBase { assertEquals(1, heatParametersAfterUpdate.size()); HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0); assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase((String) parameterData.getUniqueId())); - Either parameterNodeAfterUpdate = titanDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class); + Either parameterNodeAfterUpdate = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterUpdate.isLeft()); // delete new artifact @@ -259,25 +258,25 @@ public class ArtifactOperationTest extends ModelTestBase { assertTrue(removeArifact.isLeft()); // verify old artifact and parameter still exist - origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); + origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class); assertTrue(origArtifact.isLeft()); origArtifactData = origArtifact.left().value(); assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition() .getArtifactVersion()); - parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); + parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isLeft()); // verify new artifact is deleted - Either artifactAfterDelete = titanDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class); + Either artifactAfterDelete = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class); assertTrue(artifactAfterDelete.isRight()); - parameterNodeAfterDelete = titanDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class); + parameterNodeAfterDelete = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class); assertTrue(parameterNodeAfterDelete.isRight()); artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); - titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class); + janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class); } private ArtifactDefinition createResourceWithHeat() { @@ -369,8 +368,8 @@ public class ArtifactOperationTest extends ModelTestBase { private void deleteAndCreateCategory(String category) { String[] names = category.split("/"); - OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao); - OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao); + OperationTestsUtil.deleteAndCreateServiceCategory(category, janusGraphDao); + OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphDao); } private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) { @@ -384,9 +383,9 @@ public class ArtifactOperationTest extends ModelTestBase { userData.setRole("ADMIN"); } - titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); - titanDao.createNode(userData, UserData.class); - titanDao.commit(); + janusGraphDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); + janusGraphDao.createNode(userData, UserData.class); + janusGraphDao.commit(); return userData; } @@ -395,7 +394,7 @@ public class ArtifactOperationTest extends ModelTestBase { ResourceMetadataData serviceData1 = new ResourceMetadataData(); serviceData1.getMetadataDataDefinition().setUniqueId(resourceName); - Either createNode = titanDao.createNode(serviceData1, ResourceMetadataData.class); + Either createNode = janusGraphDao.createNode(serviceData1, ResourceMetadataData.class); assertTrue("check resource created", createNode.isLeft()); return createNode.left().value(); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java index f853553911..b003c93fc1 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java @@ -25,8 +25,8 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import java.util.ArrayList; import java.util.HashMap; @@ -44,10 +44,9 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; import org.openecomp.sdc.be.model.ModelTestBase; @@ -62,23 +61,15 @@ import org.openecomp.sdc.be.resources.data.CapabilityTypeData; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import javax.annotation.Resource; -import java.util.*; -import java.util.Map.Entry; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.Stream; - import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.*; import static org.junit.Assert.assertTrue; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:application-context-test.xml") public class CapabilityTypeOperationTest extends ModelTestBase { - @Resource(name = "titan-generic-dao") - private HealingTitanGenericDao titanDao; + @Resource(name = "janusgraph-generic-dao") + private HealingJanusGraphGenericDao janusGraphDao; @Resource(name = "capability-type-operation") private CapabilityTypeOperation capabilityTypeOperation; @@ -90,20 +81,20 @@ public class CapabilityTypeOperationTest extends ModelTestBase { @Before public void cleanUp() { - HealingTitanGenericDao titanGenericDao = capabilityTypeOperation.titanGenericDao; - Either graphResult = titanGenericDao.getGraph(); - TitanGraph graph = graphResult.left().value(); + HealingJanusGraphGenericDao janusGraphGenericDao = capabilityTypeOperation.janusGraphGenericDao; + Either graphResult = janusGraphGenericDao.getGraph(); + JanusGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } } - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } @Test @@ -124,7 +115,7 @@ public class CapabilityTypeOperationTest extends ModelTestBase { CapabilityTypeDefinition capabilityTypeAdded = addCapabilityType1.left().value(); compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded); - Either capabilityTypeByUid = capabilityTypeOperation.getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId()); + Either capabilityTypeByUid = capabilityTypeOperation.getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId()); compareBetweenCreatedToSent(capabilityTypeByUid.left().value(), capabilityTypeDefinition); Either addCapabilityType2 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true); @@ -441,7 +432,7 @@ public class CapabilityTypeOperationTest extends ModelTestBase { } private void verifyDerivedFromNodeEqualsToRootCapabilityType(CapabilityTypeDefinition rootCapabilityType, String parentCapabilityId) { - Either, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), parentCapabilityId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> derivedFromRelation = janusGraphDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), parentCapabilityId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.CapabilityType, CapabilityTypeData.class); assertThat(derivedFromRelation.left().value().getLeft().getCapabilityTypeDataDefinition()) .isEqualToComparingFieldByField(rootCapabilityType); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java index 849a442542..029c638711 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java @@ -29,7 +29,7 @@ */ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.junit.Test; import org.junit.runner.RunWith; @@ -37,10 +37,9 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ComponentInstance; import org.openecomp.sdc.be.model.ComponentInstanceInput; @@ -64,12 +63,12 @@ public class ComponentInstanceOperationTest { private ComponentInstanceOperation componentInstanceOperation; @Mock - protected HealingTitanGenericDao titanGenericDao; + protected HealingJanusGraphGenericDao janusGraphGenericDao; @Test - public void testSetTitanGenericDao() { - componentInstanceOperation.setTitanGenericDao(titanGenericDao); + public void testSetJanusGraphGenericDao() { + componentInstanceOperation.setJanusGraphGenericDao(janusGraphGenericDao); } @Test @@ -87,8 +86,8 @@ public class ComponentInstanceOperationTest { public void testUpdateCustomizationUUID() { StorageOperationStatus result; String componentInstanceId = "instanceId"; - TitanVertex titanVertex = Mockito.mock(TitanVertex.class); - when(titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(),componentInstanceId)).thenReturn(Either.left(titanVertex)); + JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class); + when(janusGraphGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(),componentInstanceId)).thenReturn(Either.left(janusGraphVertex)); result = componentInstanceOperation.updateCustomizationUUID(componentInstanceId); assertEquals(StorageOperationStatus.OK, result); } @@ -125,7 +124,8 @@ public class ComponentInstanceOperationTest { componentInstance.setUniqueId("INST0.1"); componentInstance.setComponentUid("RES0.1"); componentInstance.setGroupInstances(gilist); - when(titanGenericDao.updateNode(anyObject(),eq(ComponentInstanceData.class))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); + when(janusGraphGenericDao.updateNode(anyObject(),eq(ComponentInstanceData.class))).thenReturn(Either.right( + JanusGraphOperationStatus.GENERAL_ERROR)); Either result = componentInstanceOperation.updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, NodeTypeEnum.Component,234234545L,false); assertEquals(StorageOperationStatus.GENERAL_ERROR, result.right().value()); } @@ -145,7 +145,7 @@ public class ComponentInstanceOperationTest { componentInstance.setComponentUid("RES0.1"); componentInstance.setGroupInstances(gilist); ComponentInstanceData componentInstanceData = new ComponentInstanceData(); - when(titanGenericDao.updateNode(anyObject(),eq(ComponentInstanceData.class))).thenReturn(Either.left(componentInstanceData)); + when(janusGraphGenericDao.updateNode(anyObject(),eq(ComponentInstanceData.class))).thenReturn(Either.left(componentInstanceData)); Either result = componentInstanceOperation.updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, NodeTypeEnum.Component,234234545L,false); assertEquals(componentInstanceData, result.left().value()); } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java index 9b2a5d93c9..2c00d3d952 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java @@ -26,8 +26,8 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGraphClient; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphClient; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ArtifactType; import org.openecomp.sdc.be.model.ModelTestBase; @@ -56,8 +56,8 @@ public class ElementOperationTest extends ModelTestBase { @javax.annotation.Resource(name = "element-operation") private ElementOperation elementOperation; - @javax.annotation.Resource(name = "titan-generic-dao") - private TitanGenericDao titanDao; + @javax.annotation.Resource(name = "janusgraph-generic-dao") + private JanusGraphGenericDao janusGraphDao; private static String CATEGORY = "category"; private static String SUBCATEGORY = "subcategory"; @@ -112,7 +112,7 @@ public class ElementOperationTest extends ModelTestBase { // @Test public void testGetResourceAndServiceCategoty() { - String id = OperationTestsUtil.deleteAndCreateResourceCategory(CATEGORY, SUBCATEGORY, titanDao); + String id = OperationTestsUtil.deleteAndCreateResourceCategory(CATEGORY, SUBCATEGORY, janusGraphDao); Either res = elementOperation.getCategory(NodeTypeEnum.ResourceNewCategory, id); assertTrue(res.isLeft()); @@ -120,7 +120,7 @@ public class ElementOperationTest extends ModelTestBase { assertEquals(CATEGORY, categoryDefinition.getName()); assertEquals(SUBCATEGORY, categoryDefinition.getSubcategories().get(0).getName()); - id = OperationTestsUtil.deleteAndCreateServiceCategory(CATEGORY, titanDao); + id = OperationTestsUtil.deleteAndCreateServiceCategory(CATEGORY, janusGraphDao); res = elementOperation.getCategory(NodeTypeEnum.ServiceNewCategory, id); assertTrue(res.isLeft()); @@ -129,7 +129,7 @@ public class ElementOperationTest extends ModelTestBase { } private ElementOperation createTestSubject() { - return new ElementOperation(new TitanGenericDao(new TitanGraphClient())); + return new ElementOperation(new JanusGraphGenericDao(new JanusGraphClient())); } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java index 0f8e294459..8e1e5d3d04 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java @@ -1,7 +1,7 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Edge; @@ -10,11 +10,10 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.*; @@ -44,8 +43,8 @@ public class GroupTypeOperationTest extends ModelTestBase { private static final String TOSCA_GROUPS_ROOT = "tosca.groups.Root"; private static final String NULL_STRING = null; - @Resource(name = "titan-generic-dao") - private HealingTitanGenericDao titanDao; + @Resource(name = "janusgraph-generic-dao") + private HealingJanusGraphGenericDao janusGraphDao; @Resource(name = "capability-type-operation") private CapabilityTypeOperation capabilityTypeOperation; @@ -60,7 +59,7 @@ public class GroupTypeOperationTest extends ModelTestBase { @After public void tearDown() { - titanDao.rollback(); + janusGraphDao.rollback(); cleanUp(); } @@ -120,10 +119,12 @@ public class GroupTypeOperationTest extends ModelTestBase { assertTrue("check group type added", addGroupTypeResult.isLeft()); compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); - Either groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); + Either groupTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); GroupTypeData groupTypeNode = extractVal(groupTypeResult); - Either edgeResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); + Either edgeResult = janusGraphDao + .getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); validate(edgeResult); } @@ -132,7 +133,8 @@ public class GroupTypeOperationTest extends ModelTestBase { getOrCreateRootGroupTypeNode(); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(null); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -171,7 +173,8 @@ public class GroupTypeOperationTest extends ModelTestBase { buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance")); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -199,7 +202,8 @@ public class GroupTypeOperationTest extends ModelTestBase { assertTrue("check group type added", addGroupTypeResult.isLeft()); compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); - Either groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); + Either groupTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); GroupTypeData groupTypeNode = extractVal(groupTypeResult); Either groupTypeDefResult = groupTypeOperation.getGroupTypeByUid(groupTypeNode.getUniqueId()); @@ -213,7 +217,8 @@ public class GroupTypeOperationTest extends ModelTestBase { CapabilityDefinition updatedCapabilityDef = capabilityDefs.get("vlan_assignment"); assertEquals(2, updatedCapabilityDef.getProperties().size()); - Either edgeDerivedFromResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); + Either edgeDerivedFromResult = janusGraphDao + .getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); validate(edgeDerivedFromResult); } @@ -226,7 +231,8 @@ public class GroupTypeOperationTest extends ModelTestBase { Map capTypeProperties = new HashMap<>(); capTypeProperties.put("vfc_instance_group_reference", property); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -254,7 +260,8 @@ public class GroupTypeOperationTest extends ModelTestBase { assertTrue("check group type added", addGroupTypeResult.isLeft()); compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); - Either groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); + Either groupTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); GroupTypeData groupTypeNode = extractVal(groupTypeResult); Either groupTypeDefResult = groupTypeOperation.getGroupTypeByUid(groupTypeNode.getUniqueId()); @@ -281,7 +288,8 @@ public class GroupTypeOperationTest extends ModelTestBase { Map capTypeProperties = new HashMap<>(); capTypeProperties.put("vfc_instance_group_reference", property); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -317,7 +325,8 @@ public class GroupTypeOperationTest extends ModelTestBase { Map capTypeProperties = new HashMap<>(); capTypeProperties.put("vfc_instance_group_reference", property); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -362,7 +371,8 @@ public class GroupTypeOperationTest extends ModelTestBase { Map capTypeProperties = new HashMap<>(); capTypeProperties.put("vfc_instance_group_reference", property); CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties); - Either capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + Either capabilityTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); extractVal(capabilityTypeResult); GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); @@ -501,7 +511,8 @@ public class GroupTypeOperationTest extends ModelTestBase { private GroupTypeData getOrCreateRootGroupTypeNode() { - Either groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class); + Either groupTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class); if(groupTypeResult.isLeft()) { return groupTypeResult.left().value(); } @@ -514,7 +525,8 @@ public class GroupTypeOperationTest extends ModelTestBase { Either addGroupTypeResult = groupTypeOperation.addGroupType(rootGroupDefinition, false); assertTrue("check group type added", addGroupTypeResult.isLeft()); - Either groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class); + Either groupTypeResult = janusGraphDao + .getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class); return extractVal(groupTypeResult); } @@ -603,11 +615,11 @@ public class GroupTypeOperationTest extends ModelTestBase { assertEquals(expected.getDescription(), actual.getDescription()); } - private void validate(Either result) { + private void validate(Either result) { extractVal(result); } - private T extractVal(Either result) { + private T extractVal(Either result) { assertTrue(result.isLeft()); T t = result.left().value(); assertNotNull(t); @@ -616,19 +628,19 @@ public class GroupTypeOperationTest extends ModelTestBase { } private void cleanUp() { - Either graphResult = titanDao.getGraph(); - TitanGraph graph = graphResult.left().value(); + Either graphResult = janusGraphDao.getGraph(); + JanusGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } } - titanDao.commit(); + janusGraphDao.commit(); } @@ -764,17 +776,19 @@ public class GroupTypeOperationTest extends ModelTestBase { } private void verifyDerivedFromNodeEqualsToRootGroupType(GroupTypeDefinition rootGroupType, String parentGroupId) { - Either, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> derivedFromRelation = janusGraphDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.GroupType, GroupTypeData.class); assertThat(derivedFromRelation.left().value().getLeft().getGroupTypeDataDefinition()) .isEqualToComparingFieldByField(rootGroupType); } private void verifyDerivedFromRelationDoesntExist(String parentGroupId) { - Either, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> derivedFromRelation = janusGraphDao + .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.GroupType, GroupTypeData.class); assertThat(derivedFromRelation.right().value()) - .isEqualTo(TitanOperationStatus.NOT_FOUND); + .isEqualTo(JanusGraphOperationStatus.NOT_FOUND); } private GroupTypeDefinition createGroupTypeDef() { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java index 61504db727..958f7c878b 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java @@ -26,9 +26,9 @@ import org.junit.Test; import org.mockito.Mockito; import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.HeatParameterDefinition; import org.openecomp.sdc.be.model.ModelTestBase; @@ -48,11 +48,11 @@ public class HeatParametersOperationTest extends ModelTestBase { HeatParametersOperation heatParametersOperation = new HeatParametersOperation(); - TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class); + JanusGraphGenericDao janusGraphGenericDao = Mockito.mock(JanusGraphGenericDao.class); @Before public void setup() { - heatParametersOperation.setTitanGenericDao(titanGenericDao); + heatParametersOperation.setJanusGraphGenericDao(janusGraphGenericDao); } @@ -64,15 +64,15 @@ public class HeatParametersOperationTest extends ModelTestBase { HeatParameterData propertyData = new HeatParameterData(property); - Either either = Either.left(propertyData); + Either either = Either.left(propertyData); GraphRelation graphRelation = new GraphRelation(); - Either relationResult = Either.left(graphRelation); + Either relationResult = Either.left(graphRelation); - when(titanGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either); - when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); + when(janusGraphGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either); + when(janusGraphGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); - Either result = heatParametersOperation.addPropertyToGraph(propName, property, "resourceId.artifactId", NodeTypeEnum.ArtifactRef); + Either result = heatParametersOperation.addPropertyToGraph(propName, property, "resourceId.artifactId", NodeTypeEnum.ArtifactRef); assertTrue(result.isLeft()); @@ -91,13 +91,13 @@ public class HeatParametersOperationTest extends ModelTestBase { HeatParameterData propertyData = new HeatParameterData(property); - Either either = Either.left(propertyData); + Either either = Either.left(propertyData); GraphRelation graphRelation = new GraphRelation(); - Either relationResult = Either.left(graphRelation); + Either relationResult = Either.left(graphRelation); - when(titanGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either); - when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); + when(janusGraphGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either); + when(janusGraphGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); StorageOperationStatus result = heatParametersOperation.addPropertiesToGraph(parameters, "resourceId.artifactId", NodeTypeEnum.ArtifactRef); @@ -222,16 +222,16 @@ public class HeatParametersOperationTest extends ModelTestBase { propertyData.setUniqueId("bla"); propertyData.setValue("value1"); - Either either = Either.left(propertyData); + Either either = Either.left(propertyData); GraphRelation graphRelation = new GraphRelation(); - Either relationResult = Either.left(graphRelation); + Either relationResult = Either.left(graphRelation); - when(titanGenericDao.createNode(any(HeatParameterValueData.class), eq(HeatParameterValueData.class))).thenReturn(either); - when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.PARAMETER_VALUE), anyMap())).thenReturn(relationResult); - when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.PARAMETER_IMPL), isNull())).thenReturn(relationResult); + when(janusGraphGenericDao.createNode(any(HeatParameterValueData.class), eq(HeatParameterValueData.class))).thenReturn(either); + when(janusGraphGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.PARAMETER_VALUE), anyMap())).thenReturn(relationResult); + when(janusGraphGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.PARAMETER_IMPL), isNull())).thenReturn(relationResult); - Either result = heatParametersOperation.addHeatValueToGraph(property, "artifactLabel", "resourceInstanceId.artifactId", "resourceInstanceId"); + Either result = heatParametersOperation.addHeatValueToGraph(property, "artifactLabel", "resourceInstanceId.artifactId", "resourceInstanceId"); assertTrue(result.isLeft()); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java index 3e8b087fb2..532e76bba8 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java @@ -33,8 +33,8 @@ import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ArtifactDefinition; @@ -72,7 +72,7 @@ public class InterfaceLifecycleOperationTest { private static String USER_ID = "muUserId"; private static String CATEGORY_NAME = "category/mycategory"; - TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class); + JanusGraphGenericDao janusGraphGenericDao = Mockito.mock(JanusGraphGenericDao.class); @InjectMocks private InterfaceLifecycleOperation interfaceLifecycleOperation = new InterfaceLifecycleOperation(); @@ -87,7 +87,7 @@ public class InterfaceLifecycleOperationTest { MockitoAnnotations.initMocks(this); final String UNIQUE_ID = "UNIQUE_ID"; CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceCategory); - when(titanGenericDao.createNode(any(),any())).thenReturn(Either.left(categoryData)); + when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(categoryData)); deleteAndCreateCategory(CATEGORY_NAME); deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID); } @@ -124,7 +124,7 @@ public class InterfaceLifecycleOperationTest { String reqRelationship = "myrelationship"; ResourceOperationTest resourceOperationTest = new ResourceOperationTest(); - resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation); + resourceOperationTest.setOperations(janusGraphDao, resourceOperation, propertyOperation); Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "100.0", null, true, true); @@ -161,7 +161,7 @@ public class InterfaceLifecycleOperationTest { String softwareCompName = "tosca.nodes.SoftwareComponent"; ResourceOperationTest resourceOperationTest = new ResourceOperationTest(); - resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation); + resourceOperationTest.setOperations(janusGraphDao, resourceOperation, propertyOperation); Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "200.0", null, true, true); @@ -178,7 +178,7 @@ public class InterfaceLifecycleOperationTest { ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId()); resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name()); - Either updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class); + Either updateNode = janusGraphDao.updateNode(resourceData, ResourceMetadataData.class); assertTrue(updateNode.isLeft()); Either fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId()); @@ -198,7 +198,7 @@ public class InterfaceLifecycleOperationTest { Either opResult = interfaceOperation.updateInterfaceOperation(softwareComponent.getUniqueId(), "standard", "create", op); // PrintGraph pg = new PrintGraph(); - // System.out.println(pg.buildGraphForWebgraphWiz(titanDao.getGraph().left().value())); + // System.out.println(pg.buildGraphForWebgraphWiz(janusGraphDao.getGraph().left().value())); assertTrue(opResult.isLeft()); log.debug("{}", opResult.left().value()); @@ -247,12 +247,12 @@ public class InterfaceLifecycleOperationTest { private void deleteAndCreateCategory(String category) { String[] names = category.split("/"); - OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanGenericDao); + OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphGenericDao); /* * CategoryData categoryData = new CategoryData(); categoryData.setName(category); * - * titanDao.deleteNode(categoryData, CategoryData.class); Either createNode = titanDao .createNode(categoryData, CategoryData.class); System.out.println("after creating caetgory " + createNode); + * janusGraphDao.deleteNode(categoryData, CategoryData.class); Either createNode = janusGraphDao .createNode(categoryData, CategoryData.class); System.out.println("after creating caetgory " + createNode); */ } @@ -263,18 +263,18 @@ public class InterfaceLifecycleOperationTest { userData.setFirstName(firstName); userData.setLastName(lastName); - titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, + janusGraphGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); - titanGenericDao.createNode(userData, UserData.class); - titanGenericDao.commit(); + janusGraphGenericDao.createNode(userData, UserData.class); + janusGraphGenericDao.commit(); return userData; } @Test public void testGetAllInterfaceLifecycleTypes_TypesNotFound() { - when(titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), - InterfaceData.class)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), + InterfaceData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); Either, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); Assert.assertEquals(types.isRight(), Boolean.TRUE); } @@ -288,12 +288,13 @@ public class InterfaceLifecycleOperationTest { interfaceData.getInterfaceDataDefinition().setType(TYPE); List interfaceDataList = new ArrayList<>(); interfaceDataList.add(interfaceData); - Either, TitanOperationStatus> allInterfaceTypes = Either.left(interfaceDataList); - when(titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class)).thenReturn(allInterfaceTypes); + Either, JanusGraphOperationStatus> allInterfaceTypes = Either.left(interfaceDataList); + when(janusGraphGenericDao + .getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class)).thenReturn(allInterfaceTypes); List> list = new ArrayList<>(); - Either>, TitanOperationStatus> childrenNodes = Either.left(list); - when(titanGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(childrenNodes); + Either>, JanusGraphOperationStatus> childrenNodes = Either.left(list); + when(janusGraphGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(childrenNodes); Either, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); Assert.assertEquals(types.left().value().size(),1); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java index ef1025f77e..f5197f05c5 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java @@ -26,8 +26,8 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import java.util.Iterator; import java.util.List; @@ -39,10 +39,10 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ModelTestBase; @@ -64,7 +64,7 @@ public class PolicyTypeOperationTest extends ModelTestBase { private PolicyTypeOperation policyTypeOperation; @Autowired - private HealingTitanGenericDao titanGenericDao; + private HealingJanusGraphGenericDao janusGraphGenericDao; @BeforeClass public static void setupBeforeClass() { @@ -74,20 +74,20 @@ public class PolicyTypeOperationTest extends ModelTestBase { @Before public void cleanUp() { - TitanGenericDao titanGenericDao = policyTypeOperation.titanGenericDao; - Either graphResult = titanGenericDao.getGraph(); - TitanGraph graph = graphResult.left().value(); + JanusGraphGenericDao janusGraphGenericDao = policyTypeOperation.janusGraphGenericDao; + Either graphResult = janusGraphGenericDao.getGraph(); + JanusGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } } - titanGenericDao.commit(); + janusGraphGenericDao.commit(); } @Test @@ -310,17 +310,17 @@ public class PolicyTypeOperationTest extends ModelTestBase { } private void verifyDerivedFromNodeEqualsToRootPolicyType(PolicyTypeDefinition rootPolicyType, String parentPolicyId) { - Either, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> derivedFromRelation = janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.PolicyType, PolicyTypeData.class); assertThat(derivedFromRelation.left().value().getLeft().getPolicyTypeDataDefinition()) .isEqualToComparingFieldByField(rootPolicyType); } private void verifyDerivedFromRelationDoesntExist(String parentPolicyId) { - Either, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, + Either, JanusGraphOperationStatus> derivedFromRelation = janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.PolicyType, PolicyTypeData.class); assertThat(derivedFromRelation.right().value()) - .isEqualTo(TitanOperationStatus.NOT_FOUND); + .isEqualTo(JanusGraphOperationStatus.NOT_FOUND); } private PolicyTypeDefinition createRootPolicyTypeOnGraph() { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java index ae428bdaff..8535c3a9f3 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java @@ -20,17 +20,17 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGraphClient; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphClient; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyRule; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; @@ -51,13 +51,13 @@ import static org.junit.Assert.*; public class PropertyOperationTest extends ModelTestBase { - HealingTitanGenericDao titanGenericDao = Mockito.mock(HealingTitanGenericDao.class); + HealingJanusGraphGenericDao janusGraphGenericDao = Mockito.mock(HealingJanusGraphGenericDao.class); - PropertyOperation propertyOperation = new PropertyOperation(titanGenericDao, null); + PropertyOperation propertyOperation = new PropertyOperation(janusGraphGenericDao, null); @Before public void setup() { - propertyOperation.setTitanGenericDao(titanGenericDao); + propertyOperation.setJanusGraphGenericDao(janusGraphGenericDao); } @@ -68,10 +68,10 @@ public class PropertyOperationTest extends ModelTestBase { * * PropertyData propertyData = new PropertyData(property, propertyOperation.convertConstraintsToString(constraints)); * - * Either either = Either.left(propertyData); //when(propertyDao.create((GraphNeighbourTable)anyObject(), eq(PropertyData.class), eq(NodeTypeEnum.Property))).thenReturn(either); GraphRelation graphRelation = - * new GraphRelation(); Either relationResult = Either.left(graphRelation); + * Either either = Either.left(propertyData); //when(propertyDao.create((GraphNeighbourTable)anyObject(), eq(PropertyData.class), eq(NodeTypeEnum.Property))).thenReturn(either); GraphRelation graphRelation = + * new GraphRelation(); Either relationResult = Either.left(graphRelation); * - * when(titanGenericDao.createNode((PropertyData)anyObject(), eq(PropertyData.class))).thenReturn(either); when(titanGenericDao.createRelation((GraphNode)anyObject(), (GraphNode)anyObject(), eq(GraphEdgeLabels.PROPERTY), + * when(janusGraphGenericDao.createNode((PropertyData)anyObject(), eq(PropertyData.class))).thenReturn(either); when(janusGraphGenericDao.createRelation((GraphNode)anyObject(), (GraphNode)anyObject(), eq(GraphEdgeLabels.PROPERTY), * anyMap())).thenReturn(relationResult); * * Either result = propertyOperation.addPropertyToResource(propName, property, NodeTypeEnum.Resource, "my-resource.1.0"); @@ -512,7 +512,7 @@ public class PropertyOperationTest extends ModelTestBase { } private PropertyOperation createTestSubject() { - return new PropertyOperation(new HealingTitanGenericDao(new TitanGraphClient()), null); + return new PropertyOperation(new HealingJanusGraphGenericDao(new JanusGraphClient()), null); } @@ -572,7 +572,7 @@ public class PropertyOperationTest extends ModelTestBase { String propertyName = ""; PropertyDefinition propertyDefinition = new PropertyDefinition(); String resourceId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -583,11 +583,11 @@ public class PropertyOperationTest extends ModelTestBase { @Test public void testAddPropertyToGraphByVertex() throws Exception { PropertyOperation testSubject; - TitanVertex metadataVertex = null; + JanusGraphVertex metadataVertex = null; String propertyName = ""; PropertyDefinition propertyDefinition = new PropertyDefinition(); String resourceId = ""; - TitanOperationStatus result; + JanusGraphOperationStatus result; // default test testSubject = createTestSubject(); @@ -596,20 +596,20 @@ public class PropertyOperationTest extends ModelTestBase { @Test - public void testGetTitanGenericDao() throws Exception { + public void testGetJanusGraphGenericDao() throws Exception { PropertyOperation testSubject; - TitanGenericDao result; + JanusGraphGenericDao result; // default test testSubject = createTestSubject(); - result = testSubject.getTitanGenericDao(); + result = testSubject.getJanusGraphGenericDao(); } @Test public void testDeletePropertyFromGraph() throws Exception { PropertyOperation testSubject; String propertyId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -636,7 +636,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyOperation testSubject; String propertyId = ""; PropertyDefinition propertyDefinition = null; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -645,14 +645,14 @@ public class PropertyOperationTest extends ModelTestBase { @Test - public void testSetTitanGenericDao() { + public void testSetJanusGraphGenericDao() { PropertyOperation testSubject; - HealingTitanGenericDao titanGenericDao = null; + HealingJanusGraphGenericDao janusGraphGenericDao = null; // default test testSubject = createTestSubject(); - testSubject.setTitanGenericDao(titanGenericDao); + testSubject.setJanusGraphGenericDao(janusGraphGenericDao); } @@ -663,7 +663,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyDefinition propertyDefinition = new PropertyDefinition(); NodeTypeEnum nodeType = NodeTypeEnum.Attribute; String uniqueId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -676,7 +676,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyOperation testSubject; NodeTypeEnum nodeType = null; String uniqueId = ""; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test testSubject = createTestSubject(); @@ -760,7 +760,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyOperation testSubject; String resourceInstanceId = ""; String propertyId = ""; - ImmutablePair result; + ImmutablePair result; // default test testSubject = createTestSubject(); @@ -785,7 +785,7 @@ public class PropertyOperationTest extends ModelTestBase { public void testGetAllPropertiesOfResourceInstanceOnlyPropertyDefId() throws Exception { PropertyOperation testSubject; String resourceInstanceUid = ""; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test testSubject = createTestSubject(); @@ -798,7 +798,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyOperation testSubject; String propertyValueUid = ""; String resourceInstanceId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -882,7 +882,7 @@ public class PropertyOperationTest extends ModelTestBase { PropertyOperation testSubject; String resourceInstanceUid = ""; NodeTypeEnum instanceNodeType = null; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test testSubject = createTestSubject(); @@ -896,7 +896,7 @@ public class PropertyOperationTest extends ModelTestBase { List pathOfComponentInstances = null; String propertyUniqueId = ""; String defaultValue = ""; - Either result; + Either result; // test 1 testSubject = createTestSubject(); @@ -927,7 +927,7 @@ public class PropertyOperationTest extends ModelTestBase { public void testGetDataTypeByUid() throws Exception { PropertyOperation testSubject; String uniqueId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -988,7 +988,7 @@ public class PropertyOperationTest extends ModelTestBase { public void testGetDataTypeByUidWithoutDerivedDataTypes() throws Exception { PropertyOperation testSubject; String uniqueId = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -1000,7 +1000,7 @@ public class PropertyOperationTest extends ModelTestBase { public void testIsDefinedInDataTypes() throws Exception { PropertyOperation testSubject; String propertyType = ""; - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -1011,7 +1011,7 @@ public class PropertyOperationTest extends ModelTestBase { @Test public void testGetAllDataTypes() throws Exception { PropertyOperation testSubject; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test testSubject = createTestSubject(); @@ -1023,7 +1023,7 @@ public class PropertyOperationTest extends ModelTestBase { public void testCheckInnerType() throws Exception { PropertyOperation testSubject; PropertyDataDefinition propDataDef = new PropertyDataDefinition(); - Either result; + Either result; // default test testSubject = createTestSubject(); @@ -1034,7 +1034,7 @@ public class PropertyOperationTest extends ModelTestBase { @Test public void testGetAllDataTypeNodes() throws Exception { PropertyOperation testSubject; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // default test testSubject = createTestSubject(); @@ -1083,7 +1083,7 @@ public class PropertyOperationTest extends ModelTestBase { String uniqueId = ""; NodeTypeEnum elementType = null; List properties = null; - Either, TitanOperationStatus> result; + Either, JanusGraphOperationStatus> result; // test 1 testSubject = createTestSubject(); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperationTest.java index 3d60a650f3..30463e9982 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperationTest.java @@ -44,9 +44,8 @@ import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.mockito.Spy; import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; -import org.openecomp.sdc.be.dao.titan.HealingTitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ModelTestBase; @@ -70,7 +69,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { private static final String PROP = "prop"; @Mock - HealingTitanGenericDao titanGenericDao; + HealingJanusGraphGenericDao janusGraphGenericDao; @Mock PropertyOperation propertyOperation; @@ -101,16 +100,16 @@ public class RelationshipTypeOperationTest extends ModelTestBase { public void setUp() throws Exception { MockitoAnnotations.initMocks(this); - Mockito.doReturn(TitanOperationStatus.OK).when(titanGenericDao).commit(); - Mockito.doReturn(TitanOperationStatus.OK).when(titanGenericDao).rollback(); + Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).commit(); + Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).rollback(); } @Test public void getRelationshipTypeByNameNotCreated() { - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CREATED)) + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CREATED)) .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString()); - Either either = + Either either = relationshipTypeOperation.getRelationshipTypeByName("name"); assertTrue(either.isRight()); } @@ -122,7 +121,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { @Test public void testAddRelationshipTypeValidationFailStatusNullInTransactionFalse() { - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED)) + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED)) .when(propertyOperation) .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any()); @@ -137,7 +136,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { public void testAddRelationshipTypeValidationFailStatusPropertiesReturnedInTransactionFalse() { Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation) .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any()); - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_FOUND)).when(propertyOperation) + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(propertyOperation) .validatePropertiesUniqueness(Mockito.any(), Mockito.any()); Either addRelationshipType = @@ -148,20 +147,22 @@ public class RelationshipTypeOperationTest extends ModelTestBase { @Test public void testGetAllRelationshipTypesNotFound() { - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_FOUND)).when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when( + janusGraphGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, RelationshipTypeData.class); - Either, TitanOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(); + Either, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(); assertTrue(either.isLeft() && MapUtils.isEmpty(either.left().value())); } @Test public void testGetAllRelationshipTypesNotConnnected() { - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED)).when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED)).when( + janusGraphGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, RelationshipTypeData.class); - Either, TitanOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(); + Either, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(); - assertTrue(either.isRight() && TitanOperationStatus.NOT_CONNECTED == either.right().value()); + assertTrue(either.isRight() && JanusGraphOperationStatus.NOT_CONNECTED == either.right().value()); } @Test @@ -177,10 +178,10 @@ public class RelationshipTypeOperationTest extends ModelTestBase { relationshipTypeDataList.add(relationshipTypeData1); Mockito.doReturn(Either.left(relationshipTypeDataList)) - .when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, + .when(janusGraphGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null, RelationshipTypeData.class); - Mockito.doReturn(Either.left(relationshipTypeData1)).when(titanGenericDao) + Mockito.doReturn(Either.left(relationshipTypeData1)).when(janusGraphGenericDao) .getNode(Mockito.anyString(), Mockito.anyString(), Mockito.eq(RelationshipTypeData.class)); Mockito.doReturn(Either.left(createPropertyData("prop1"))).when(propertyOperation) @@ -194,7 +195,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { .when(derivedFromOperation) .getDerivedFromChild("tosca.relationships.Root1", NodeTypeEnum.RelationshipType, RelationshipTypeData.class); - Either, TitanOperationStatus> either = + Either, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(); assertTrue(either.isLeft()); @@ -352,7 +353,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation) .validatePropertiesUniqueness(Mockito.any(), Mockito.any()); - Mockito.doReturn(Either.left(relationshipTypeData)).when(titanGenericDao) + Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao) .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class)); Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation) @@ -376,7 +377,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { @Test public void testGetRelationshipTypeNotConnected() { - Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED)) + Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED)) .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString()); Either either = @@ -405,7 +406,8 @@ public class RelationshipTypeOperationTest extends ModelTestBase { newRelationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root"); newRelationshipTypeDefinition.setProperties(createPropertyData("prop1")); - Mockito.doReturn(Either.left(new RelationshipTypeData(newRelationshipTypeDefinition))).when(titanGenericDao) + Mockito.doReturn(Either.left(new RelationshipTypeData(newRelationshipTypeDefinition))).when( + janusGraphGenericDao) .updateNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class)); Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties())) @@ -435,7 +437,7 @@ public class RelationshipTypeOperationTest extends ModelTestBase { public void testGetRelationshipTypeByUid() { RelationshipTypeData relationshipTypeData = new RelationshipTypeData(relationshipTypeDefinition); - Mockito.doReturn(Either.left(relationshipTypeData)).when(titanGenericDao) + Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao) .getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class)); Mockito.doReturn(Either.left(relationshipTypeDefinition.getProperties())) @@ -444,11 +446,12 @@ public class RelationshipTypeOperationTest extends ModelTestBase { RelationshipTypeDefinition childRelationshipTypeDefinition = new RelationshipTypeDefinition(); childRelationshipTypeDefinition.setType("tosca.relationships.ContainerChild"); - Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(childRelationshipTypeDefinition), null))).when(titanGenericDao) + Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(childRelationshipTypeDefinition), null))).when( + janusGraphGenericDao) .getChild(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class)); - Either either = + Either either = relationshipTypeOperation.getRelationshipTypeByUid("tosca.relationships.Container1"); assertTrue(either.isLeft() diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java index c70e41b2f1..aef1642e3f 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java @@ -20,18 +20,18 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import fj.data.Either; import org.junit.*; import org.junit.rules.TestName; import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; @@ -47,13 +47,13 @@ import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.catalog.CatalogComponent; import org.openecomp.sdc.be.model.category.CategoryDefinition; import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; -import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; -import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; -import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation; -import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaElementLifecycleOperation; -import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementLifecycleOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.common.util.ValidationUtils; import org.springframework.test.context.ContextConfiguration; @@ -70,7 +70,7 @@ import static org.junit.Assert.assertTrue; public class ToscaElementLifecycleOperationTest extends ModelTestBase { @javax.annotation.Resource - protected TitanDao titanDao; + protected JanusGraphDao janusGraphDao; @javax.annotation.Resource private NodeTypeOperation nodeTypeOperation; @@ -105,7 +105,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { createUsers(); createResourceCategory(); createServiceCategory(); - GraphTestUtils.createRootCatalogVertex(titanDao); + GraphTestUtils.createRootCatalogVertex(janusGraphDao); rootVertex = createRootNodeType(); createNodeType("firstVf"); serviceVertex = createTopologyTemplate("firstService"); @@ -263,7 +263,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); verifyInCatalogData(4, null); - // exportGraphMl(titanDao.getGraph().left().value()); + // exportGraphMl(janusGraphDao.getGraph().left().value()); } @@ -322,7 +322,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { public void testGetToscaElOwner_Fail(){ Either result; String toscaEleId = "toscaElementId"; - titanDao.getVertexById(toscaEleId, JsonParseFlagEnum.NoParse); + janusGraphDao.getVertexById(toscaEleId, JsonParseFlagEnum.NoParse); result = lifecycleOperation.getToscaElementOwner(toscaEleId); assertEquals(StorageOperationStatus.NOT_FOUND, result.right().value()); } @@ -351,12 +351,14 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { subCat.setMetadataProperties(metadataProperties); subCat.updateMetadataJsonWithCurrentMetadataProperties(); - Either catRes = titanDao.createVertex(cat); + Either catRes = janusGraphDao.createVertex(cat); - Either subCatRes = titanDao.createVertex(subCat); + Either subCatRes = janusGraphDao.createVertex(subCat); - TitanOperationStatus status = titanDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), EdgeLabelEnum.SUB_CATEGORY, new HashMap<>()); - assertEquals(TitanOperationStatus.OK, status); + JanusGraphOperationStatus + status = janusGraphDao + .createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), EdgeLabelEnum.SUB_CATEGORY, new HashMap<>()); + assertEquals(JanusGraphOperationStatus.OK, status); } private void createServiceCategory() { @@ -372,7 +374,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { cat.setMetadataProperties(metadataProperties); cat.updateMetadataJsonWithCurrentMetadataProperties(); - Either catRes = titanDao.createVertex(cat); + Either catRes = janusGraphDao.createVertex(cat); assertTrue(catRes.isLeft()); } @@ -398,7 +400,8 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { Either createRes = topologyTemplateOperation.createTopologyTemplate(service); assertTrue(createRes.isLeft()); - Either getNodeTyeRes = titanDao.getVertexById(createRes.left().value().getUniqueId()); + Either getNodeTyeRes = janusGraphDao + .getVertexById(createRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); // serviceVertex = getNodeTyeRes.left().value(); @@ -436,7 +439,8 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { Either createVFRes = nodeTypeOperation.createNodeType(vf); assertTrue(createVFRes.isLeft()); - Either getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId()); + Either getNodeTyeRes = janusGraphDao + .getVertexById(createVFRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); vfVertex = getNodeTyeRes.left().value(); @@ -482,7 +486,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { Either res = nodeTypeOperation.associateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); - // exportGraphMl(titanDao.getGraph().left().value()); + // exportGraphMl(janusGraphDao.getGraph().left().value()); List pathKeys = new ArrayList<>(); pathKeys.add("capName"); @@ -542,7 +546,8 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { Either createVFRes = nodeTypeOperation.createNodeType(vf); assertTrue(createVFRes.isLeft()); - Either getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId()); + Either getNodeTyeRes = janusGraphDao + .getVertexById(createVFRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); return getNodeTyeRes.left().value(); } @@ -559,7 +564,7 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { ownerV.setMetadataProperties(metadataProperties); ownerV.updateMetadataJsonWithCurrentMetadataProperties(); ownerV.setJson(new HashMap<>()); - Either createUserRes = titanDao.createVertex(ownerV); + Either createUserRes = janusGraphDao.createVertex(ownerV); assertTrue(createUserRes.isLeft()); ownerVertex = createUserRes.left().value(); @@ -574,12 +579,12 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { modifierV.setMetadataProperties(metadataProperties); modifierV.updateMetadataJsonWithCurrentMetadataProperties(); modifierV.setJson(new HashMap<>()); - createUserRes = titanDao.createVertex(modifierV); + createUserRes = janusGraphDao.createVertex(modifierV); assertTrue(createUserRes.isLeft()); modifierVertex = createUserRes.left().value(); - Either getOwnerRes = lifecycleOperation.findUser(ownerVertex.getUniqueId()); + Either getOwnerRes = lifecycleOperation.findUser(ownerVertex.getUniqueId()); assertTrue(getOwnerRes.isLeft()); } @@ -602,17 +607,17 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { } private void clearGraph() { - Either graphResult = titanDao.getGraph(); - TitanGraph graph = graphResult.left().value(); + Either graphResult = janusGraphDao.getGraph(); + JanusGraph graph = graphResult.left().value(); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { - TitanVertex vertex = iterator.next(); + JanusGraphVertex vertex = iterator.next(); vertex.remove(); } } - titanDao.commit(); + janusGraphDao.commit(); } } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java index 5226a468d7..c094999ebc 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java @@ -20,10 +20,10 @@ package org.openecomp.sdc.be.model.operations.impl; -import com.thinkaurelius.titan.core.*; -import com.thinkaurelius.titan.graphdb.relations.StandardVertexProperty; -import com.thinkaurelius.titan.graphdb.types.system.EmptyVertex; -import com.thinkaurelius.titan.graphdb.types.system.ImplicitKey; +import org.janusgraph.core.*; +import org.janusgraph.graphdb.relations.StandardVertexProperty; +import org.janusgraph.graphdb.types.system.EmptyVertex; +import org.janusgraph.graphdb.types.system.ImplicitKey; import fj.data.Either; import org.apache.tinkerpop.gremlin.structure.*; import org.junit.Before; @@ -34,9 +34,9 @@ import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.mockito.stubbing.Answer; import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.dao.utils.UserStatusEnum; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ModelTestBase; @@ -59,9 +59,10 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; public class UserAdminOperationTest extends ModelTestBase { - private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class); + private static final JanusGraphGenericDao JANUS_GRAPH_GENERIC_DAO = mock(JanusGraphGenericDao.class); @InjectMocks - private static final UserAdminOperation userAdminOperation = new UserAdminOperation(titanGenericDao); + private static final UserAdminOperation userAdminOperation = new UserAdminOperation( + JANUS_GRAPH_GENERIC_DAO); private static final String ADMIN = "admin"; @BeforeClass @@ -72,20 +73,20 @@ public class UserAdminOperationTest extends ModelTestBase { @Before public void initMocks() { MockitoAnnotations.initMocks(this); - Mockito.reset(titanGenericDao); - mockTitanUpdate(); - mockTitanDelete(); + Mockito.reset(JANUS_GRAPH_GENERIC_DAO); + mockJanusGraphUpdate(); + mockJanusGraphDelete(); } @Test public void testDeActivateUserDataSuccess() { - UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true); + UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true); Either eitherUser = userAdminOperation.deActivateUser(userAdminOperation.convertToUser(userData)); - verify(titanGenericDao, times(1)).updateNode(eq(userData), eq(UserData.class)); - verify(titanGenericDao, times(0)).deleteNode(any(UserData.class), eq(UserData.class)); + verify(JANUS_GRAPH_GENERIC_DAO, times(1)).updateNode(eq(userData), eq(UserData.class)); + verify(JANUS_GRAPH_GENERIC_DAO, times(0)).deleteNode(any(UserData.class), eq(UserData.class)); assertTrue(eitherUser.isLeft()); User user = eitherUser.left().value(); assertSame(user.getStatus(), UserStatusEnum.INACTIVE); @@ -93,33 +94,33 @@ public class UserAdminOperationTest extends ModelTestBase { @Test public void testDeleteUserWithoutResources() { - UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true); + UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true); List edgesList = new ArrayList<>(); - Either, TitanOperationStatus> eitherResult = Either.left(edgesList); - when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult); + Either, JanusGraphOperationStatus> eitherResult = Either.left(edgesList); + when(JANUS_GRAPH_GENERIC_DAO.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult); Either eitherUser = userAdminOperation.deleteUserData(ADMIN); - verify(titanGenericDao, times(0)).updateNode(any(UserData.class), eq(UserData.class)); - verify(titanGenericDao, times(1)).deleteNode(userData, UserData.class); + verify(JANUS_GRAPH_GENERIC_DAO, times(0)).updateNode(any(UserData.class), eq(UserData.class)); + verify(JANUS_GRAPH_GENERIC_DAO, times(1)).deleteNode(userData, UserData.class); assertTrue(eitherUser.isLeft()); } @Test public void testDeleteUserWithResources() { - UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true); + UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true); List edgesList = new ArrayList<>(); edgesList.add(getEmptyEdgeImpl()); - Either, TitanOperationStatus> eitherResult = Either.left(edgesList); - when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult); + Either, JanusGraphOperationStatus> eitherResult = Either.left(edgesList); + when(JANUS_GRAPH_GENERIC_DAO.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult); Either eitherUser = userAdminOperation.deleteUserData(ADMIN); - verify(titanGenericDao, times(0)).updateNode(any(UserData.class), eq(UserData.class)); - verify(titanGenericDao, times(0)).deleteNode(any(UserData.class), eq(UserData.class)); + verify(JANUS_GRAPH_GENERIC_DAO, times(0)).updateNode(any(UserData.class), eq(UserData.class)); + verify(JANUS_GRAPH_GENERIC_DAO, times(0)).deleteNode(any(UserData.class), eq(UserData.class)); assertTrue(eitherUser.isRight()); assertSame(eitherUser.right().value(), ActionStatus.USER_HAS_ACTIVE_ELEMENTS); @@ -131,7 +132,7 @@ public class UserAdminOperationTest extends ModelTestBase { String userKey = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User); User user = new User(); user.setUserId(userId); - TitanVertex userVertex = null; + JanusGraphVertex userVertex = null; TestVertex component1 = new TestVertex(null); TestVertex component2 = new TestVertex(true); TestVertex component3 = new TestVertex(false); @@ -142,8 +143,8 @@ public class UserAdminOperationTest extends ModelTestBase { edges.add(edge1); edges.add(edge2); edges.add(edge3); - when(titanGenericDao.getVertexByProperty(userKey, userId)).thenReturn(Either.left(userVertex)); - when(titanGenericDao.getOutgoingEdgesByCriteria(any(), any(), any())).thenReturn(Either.left(edges)); + when(JANUS_GRAPH_GENERIC_DAO.getVertexByProperty(userKey, userId)).thenReturn(Either.left(userVertex)); + when(JANUS_GRAPH_GENERIC_DAO.getOutgoingEdgesByCriteria(any(), any(), any())).thenReturn(Either.left(edges)); Either, StorageOperationStatus> result = userAdminOperation.getUserPendingTasksList(user, new HashMap<>()); assertThat(result.isLeft()).isTrue(); List pendingTasks = result.left().value(); @@ -152,7 +153,7 @@ public class UserAdminOperationTest extends ModelTestBase { assertThat(((TestEdge)pendingTasks.get(1)).getName()).isNotEqualTo("2"); } - private class TestVertex implements TitanVertex { + private class TestVertex implements JanusGraphVertex { private final Boolean isDeleted; @@ -161,12 +162,12 @@ public class UserAdminOperationTest extends ModelTestBase { } @Override - public TitanEdge addEdge(String s, Vertex vertex, Object... objects) { + public JanusGraphEdge addEdge(String s, Vertex vertex, Object... objects) { return null; } @Override - public TitanVertexProperty property(String s, V v, Object... objects) { + public JanusGraphVertexProperty property(String s, V v, Object... objects) { return null; } @@ -181,7 +182,7 @@ public class UserAdminOperationTest extends ModelTestBase { } @Override - public TitanVertexProperty property(VertexProperty.Cardinality cardinality, String s, V v, Object... objects) { + public JanusGraphVertexProperty property(VertexProperty.Cardinality cardinality, String s, V v, Object... objects) { return null; } @@ -221,7 +222,7 @@ public class UserAdminOperationTest extends ModelTestBase { } @Override - public TitanVertexQuery query() { + public JanusGraphVertexQuery query() { return null; } @@ -231,7 +232,7 @@ public class UserAdminOperationTest extends ModelTestBase { } @Override - public TitanTransaction graph() { + public JanusGraphTransaction graph() { return null; } @@ -369,27 +370,28 @@ public class UserAdminOperationTest extends ModelTestBase { }; } - private UserData mockTitanGet(String userId, UserRoleEnum role, boolean isActive) { + private UserData mockJanusGraphGet(String userId, UserRoleEnum role, boolean isActive) { UserData userData = buildUserData(userId, role, isActive); - Either eitherUserData = Either.left(userData); - when(titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData); + Either eitherUserData = Either.left(userData); + when(JANUS_GRAPH_GENERIC_DAO + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData); return userData; } - private static void mockTitanUpdate() { - doAnswer((Answer>) invocation -> { + private static void mockJanusGraphUpdate() { + doAnswer((Answer>) invocation -> { Object[] args = invocation.getArguments(); UserData retValue = (UserData) args[0]; return Either.left(retValue); - }).when(titanGenericDao).updateNode(any(UserData.class), eq(UserData.class)); + }).when(JANUS_GRAPH_GENERIC_DAO).updateNode(any(UserData.class), eq(UserData.class)); } - private static void mockTitanDelete() { - doAnswer((Answer>) invocation -> { + private static void mockJanusGraphDelete() { + doAnswer((Answer>) invocation -> { Object[] args = invocation.getArguments(); UserData retValue = (UserData) args[0]; return Either.left(retValue); - }).when(titanGenericDao).deleteNode(any(UserData.class), eq(UserData.class)); + }).when(JANUS_GRAPH_GENERIC_DAO).deleteNode(any(UserData.class), eq(UserData.class)); } private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java index a0b6ea6fd3..71dc5d9517 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java @@ -21,9 +21,9 @@ package org.openecomp.sdc.be.model.operations.impl.util; import fj.data.Either; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; @@ -36,20 +36,20 @@ import org.openecomp.sdc.common.util.ValidationUtils; public class OperationTestsUtil { - public static String deleteAndCreateServiceCategory(String category, TitanGenericDao titanDao) { + public static String deleteAndCreateServiceCategory(String category, JanusGraphGenericDao janusGraphDao) { CategoryData categoryData = new CategoryData(NodeTypeEnum.ServiceNewCategory); categoryData.getCategoryDataDefinition().setName(category); categoryData.getCategoryDataDefinition() .setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(category)); categoryData.getCategoryDataDefinition().setUniqueId(UniqueIdBuilder.buildCategoryUid( ValidationUtils.normalizeCategoryName4Uniqueness(category), NodeTypeEnum.ServiceNewCategory)); - titanDao.deleteNode(categoryData, CategoryData.class); - Either createNode = titanDao.createNode(categoryData, CategoryData.class); + janusGraphDao.deleteNode(categoryData, CategoryData.class); + Either createNode = janusGraphDao.createNode(categoryData, CategoryData.class); return (String) createNode.left().value().getUniqueId(); } public static String deleteAndCreateResourceCategory(String category, String subcategory, - TitanGenericDao titanDao) { + JanusGraphGenericDao janusGraphDao) { CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceNewCategory); categoryData.getCategoryDataDefinition().setName(category); @@ -64,22 +64,22 @@ public class OperationTestsUtil { .setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(subcategory)); subcategoryData.getSubCategoryDataDefinition().setUniqueId(UniqueIdBuilder .buildSubCategoryUid(categoryData.getCategoryDataDefinition().getUniqueId(), subcategory)); - titanDao.deleteNode(categoryData, CategoryData.class); - titanDao.deleteNode(subcategoryData, SubCategoryData.class); - Either createNode = titanDao.createNode(categoryData, CategoryData.class); - titanDao.createNode(subcategoryData, SubCategoryData.class); - titanDao.createRelation(categoryData, subcategoryData, GraphEdgeLabels.SUB_CATEGORY, null); + janusGraphDao.deleteNode(categoryData, CategoryData.class); + janusGraphDao.deleteNode(subcategoryData, SubCategoryData.class); + Either createNode = janusGraphDao.createNode(categoryData, CategoryData.class); + janusGraphDao.createNode(subcategoryData, SubCategoryData.class); + janusGraphDao.createRelation(categoryData, subcategoryData, GraphEdgeLabels.SUB_CATEGORY, null); return (String) createNode.left().value().getUniqueId(); } - public static void deleteServiceCategory(String category, TitanGenericDao titanDao) { + public static void deleteServiceCategory(String category, JanusGraphGenericDao janusGraphDao) { ServiceCategoryData categoryData = new ServiceCategoryData(category); - titanDao.deleteNode(categoryData, ServiceCategoryData.class); + janusGraphDao.deleteNode(categoryData, ServiceCategoryData.class); } - public static void deleteResourceCategory(String category, String subcategory, TitanGenericDao titanDao) { + public static void deleteResourceCategory(String category, String subcategory, JanusGraphGenericDao janusGraphDao) { ResourceCategoryData categoryData = new ResourceCategoryData(category, subcategory); - titanDao.deleteNode(categoryData, ResourceCategoryData.class); + janusGraphDao.deleteNode(categoryData, ResourceCategoryData.class); } public static User convertUserDataToUser(UserData modifierData) { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java index 7ba2e097c2..6bd206725b 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java @@ -20,9 +20,9 @@ package org.openecomp.sdc.be.model.operations.impl.util; -import com.thinkaurelius.titan.core.TitanEdge; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphEdge; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; import org.apache.tinkerpop.gremlin.structure.Edge; import org.apache.tinkerpop.gremlin.structure.Element; import org.apache.tinkerpop.gremlin.structure.Property; @@ -40,12 +40,12 @@ import java.util.Set; public class PrintGraph { - public void printGraphVertices(TitanGraph graph) { + public void printGraphVertices(JanusGraph graph) { - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { Vertex vertex = iterator.next(); } @@ -55,11 +55,11 @@ public class PrintGraph { graph.tx().commit(); } - public void printGraphEdges(TitanGraph graph) { - Iterable vertices = graph.query().edges(); + public void printGraphEdges(JanusGraph graph) { + Iterable vertices = graph.query().edges(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { Edge edge = iterator.next(); @@ -69,16 +69,16 @@ public class PrintGraph { graph.tx().commit(); } - public String buildGraphForWebgraphWiz(TitanGraph graph) { + public String buildGraphForWebgraphWiz(JanusGraph graph) { StringBuilder builder = new StringBuilder(); builder.append("digraph finite_state_machine {\n"); builder.append("rankdir=LR;\n"); builder.append("size=\"15,10\" \n"); - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { Vertex vertex = iterator.next(); @@ -98,10 +98,10 @@ public class PrintGraph { } - Iterable edges = graph.query().edges(); + Iterable edges = graph.query().edges(); if (edges != null) { - Iterator iterator = edges.iterator(); + Iterator iterator = edges.iterator(); while (iterator.hasNext()) { Edge edge = iterator.next(); @@ -309,12 +309,12 @@ public class PrintGraph { return key; } - public int getNumberOfVertices(TitanGraph graph) { + public int getNumberOfVertices(JanusGraph graph) { int counter = 0; - Iterable vertices = graph.query().vertices(); + Iterable vertices = graph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { Vertex vertex = iterator.next(); counter++; @@ -323,14 +323,14 @@ public class PrintGraph { return counter; } - public Set getVerticesSet(TitanGraph titanGraph) { + public Set getVerticesSet(JanusGraph janusGraph) { Set set = new HashSet<>(); - Iterable vertices = titanGraph.query().vertices(); + Iterable vertices = janusGraph.query().vertices(); if (vertices != null) { - Iterator iterator = vertices.iterator(); + Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { Vertex vertex = iterator.next(); -- cgit 1.2.3-korg