aboutsummaryrefslogtreecommitdiffstats
path: root/catalog-model/src/test/java/org/openecomp
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-model/src/test/java/org/openecomp')
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java46
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/JsonObjectTest.java80
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java216
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java574
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java345
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationSpringTest.java543
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java136
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentOperationTest.java395
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java109
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java289
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceOperationTest.java272
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/LifecycleOperationTest.java1991
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java120
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java548
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RequirementOperationTest.java236
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceInstanceOperationTest.java2511
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperationTest.java734
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperationTest.java964
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java239
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/DataTypeValidatorTest.java1004
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java95
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java461
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/ResourceCreationUtils.java36
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/serialize/TestResourceSerialization.java222
-rw-r--r--catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/IntegerValidatorTest.java75
25 files changed, 12241 insertions, 0 deletions
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
new file mode 100644
index 0000000000..f18aa61b74
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ModelTestBase.java
@@ -0,0 +1,46 @@
+/*-
+ * ============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;
+
+import org.openecomp.sdc.be.config.Configuration;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+
+public class ModelTestBase {
+
+ protected static ConfigurationManager configurationManager;
+
+ public static void init() {
+ if (ConfigurationManager.getConfigurationManager() == null) {
+ String appConfigDir = "src/test/resources/config";
+ ConfigurationSource configurationSource = new FSConfigurationSource(
+ ExternalConfiguration.getChangeListener(), appConfigDir);
+ configurationManager = new ConfigurationManager(configurationSource);
+
+ Configuration configuration = new Configuration();
+ configuration.setTitanInMemoryGraph(true);
+
+ configurationManager.setConfiguration(configuration);
+ }
+ }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/JsonObjectTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/JsonObjectTest.java
new file mode 100644
index 0000000000..dd102e7ed5
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/JsonObjectTest.java
@@ -0,0 +1,80 @@
+/*-
+ * ============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.operations;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.sdc.be.model.UploadResourceInfo;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
+import org.openecomp.sdc.common.api.UploadArtifactInfo;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class JsonObjectTest {
+
+ private ObjectMapper mapper;
+ UploadResourceInfo inputObjectRef;
+ private final String INPUT_RESOURCE_STRING = "{ \"payloadData\" : \"My Test Object\", \"payloadName\" : \"TestName\", "
+ + " \"description\":\"my_description\",\"tags\":[\"tag1\"], "
+ + "\"artifactList\" : [ { \"artifactName\" : \"myArtifact0\", \"artifactPath\" : \"scripts/\", \"artifactType\" : \"PUPPET\", "
+ + " \"artifactDescription\" : \"This is Description\", \"artifactData\" : null }, "
+ + "{ \"artifactName\" : \"myArtifact1\", \"artifactPath\" : \"scripts/\", \"artifactType\" : \"PUPPET\", \"artifactDescription\" : \"This is Description\", "
+ + " \"artifactData\" : null } ], \"contactId\" : null, \"name\" : null, \"resourceIconPath\" : null, \"vendorName\" : null, \"vendorRelease\" : null , \"resourceType\" : \"VFC\" }";
+
+ @Before
+ public void setup() {
+ mapper = new ObjectMapper();
+ ArrayList<UploadArtifactInfo> artifactList = new ArrayList<UploadArtifactInfo>();
+ for (int i = 0; i < 2; i++) {
+ UploadArtifactInfo artifactInfo = new UploadArtifactInfo("myArtifact" + i, "scripts/",
+ ArtifactTypeEnum.PUPPET, "This is Description");
+ artifactList.add(artifactInfo);
+ }
+ ArrayList<String> tags = new ArrayList<>();
+ tags.add("tag1");
+ inputObjectRef = new UploadResourceInfo("My Test Object", "TestName", "my_description", null, tags,
+ artifactList);
+
+ }
+
+ @Test
+ public void testStringToUploadResourceInfo() throws JsonParseException, JsonMappingException, IOException {
+ UploadResourceInfo resourceObjectTest = mapper.readValue(INPUT_RESOURCE_STRING, UploadResourceInfo.class);
+ assertEquals(inputObjectRef, resourceObjectTest);
+
+ }
+
+ // @Test
+ public void testUploadResourceInfoToString() throws JsonParseException, JsonMappingException, IOException {
+ String refAsString = mapper.writeValueAsString(inputObjectRef);
+ String unFormattedString = refAsString.replace("\n", "").replace("\t", "").replace(" ", "");
+
+ assertEquals(unFormattedString, INPUT_RESOURCE_STRING.replace("\n", "").replace("\t", "").replace(" ", ""));
+
+ }
+}
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
new file mode 100644
index 0000000000..3e871f1fa0
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperationTest.java
@@ -0,0 +1,216 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+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.Point;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.operations.api.IAdditionalInformationOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.exception.DeleteReferencedObjectException;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.thinkaurelius.titan.core.TitanGraph;
+//import com.tinkerpop.blueprints.Vertex;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class AdditionalInformationOperationTest extends ModelTestBase {
+
+ private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+
+ private static String USER_ID = "muuserid";
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "additional-information-operation")
+ private IAdditionalInformationOperation additionalInformationOperation;
+
+ @Before
+ public void createUserAndCategory() {
+ deleteAndCreateCategory(CATEGORY_NAME);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
+
+ }
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+
+ ModelTestBase.init();
+
+ }
+
+ @Test
+ public void testDummy() {
+
+ assertTrue(additionalInformationOperation != null);
+
+ }
+
+ private int getNumberOfVerticesOnGraph() {
+ Either<TitanGraph, TitanOperationStatus> graphResult = titanDao.getGraph();
+ TitanGraph graph = graphResult.left().value();
+
+ int i = 0;
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ TitanVertex vertex = iterator.next();
+ i++;
+ }
+
+ }
+
+ titanDao.commit();
+
+ return i;
+ }
+
+ @Test
+ public void testCreateAndDeleteResource() {
+
+ int before = getNumberOfVerticesOnGraph();
+
+ Resource newResource = createResource(USER_ID, CATEGORY_NAME, "testCreateAndDeleteResource", "0.1", null, false,
+ true);
+ String resourceId = newResource.getUniqueId();
+
+ Either<Resource, StorageOperationStatus> deleteResource = resourceOperation.deleteResource(resourceId);
+ assertTrue(deleteResource.isLeft());
+
+ int after = getNumberOfVerticesOnGraph();
+
+ assertEquals("check number of vertices not changed", before, after);
+ }
+
+ private Resource buildResourceMetadata(String userId, String category, String resourceName,
+ String resourceVersion) {
+
+ Resource resource = new Resource();
+ resource.setName(resourceName);
+ resource.setVersion(resourceVersion);
+ ;
+ resource.setDescription("description 1");
+ resource.setAbstract(false);
+ resource.setCreatorUserId(userId);
+ resource.setContactId("contactId@sdc.com");
+ resource.setVendorName("vendor 1");
+ resource.setVendorRelease("1.0.0");
+ String[] categoryArr = category.split("/");
+ resource.addCategory(categoryArr[0], categoryArr[1]);
+ resource.setIcon("images/my.png");
+ // List<String> tags = new ArrayList<String>();
+ // tags.add("TAG1");
+ // tags.add("TAG2");
+ // resource.setTags(tags);
+ return resource;
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+ }
+
+ public Resource createResource(String userId, String category, String resourceName, String resourceVersion,
+ String parentResourceName, boolean isAbstract, boolean isHighestVersion) {
+
+ List<String> derivedFrom = new ArrayList<String>();
+ if (parentResourceName != null) {
+ derivedFrom.add(parentResourceName);
+ }
+ Resource resource = buildResourceMetadata(userId, category, resourceName, resourceVersion);
+
+ resource.setAbstract(isAbstract);
+ resource.setHighestVersion(isHighestVersion);
+
+ Either<Resource, StorageOperationStatus> result = resourceOperation.createResource(resource, true);
+
+ assertTrue(result.isLeft());
+ Resource resultResource = result.left().value();
+
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultResource.getLifecycleState());
+
+ return resultResource;
+
+ }
+
+}
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
new file mode 100644
index 0000000000..0143e50dc7
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.java
@@ -0,0 +1,574 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+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.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.HeatParameterDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+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.ArtifactData;
+import org.openecomp.sdc.be.resources.data.HeatParameterData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.UniqueIdData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+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 = "service-operation")
+ private ServiceOperation serviceOperation;
+
+ @javax.annotation.Resource
+ private IGraphLockOperation graphLockOperation;
+
+ @javax.annotation.Resource
+ private ArtifactOperation artifactOperation;
+
+ @javax.annotation.Resource(name = "requirement-operation")
+ private RequirementOperation requirementOperation;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @javax.annotation.Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation resourceInstanceOperation;
+
+ @javax.annotation.Resource(name = "lifecycle-operation")
+ private LifecycleOperation lifecycleOperation;
+
+ private static Logger log = LoggerFactory.getLogger(ServiceOperation.class.getName());
+
+ private static String RESOURCE_ID = "resourceId";
+ private static String RESOURCE_ID_2 = "resourceId2";
+
+ private static String USER_ID = "muserid";
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+
+ ModelTestBase.init();
+ }
+
+ @Before
+ public void createUserAndCategory() {
+ deleteAndCreateCategory(CATEGORY_NAME);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, null);
+ }
+
+// @Test
+ public void testAddArtifactToServiceVersionAndUUIDNotNull() {
+ CategoryDefinition category = new CategoryDefinition();
+ category.setName(CATEGORY_NAME);
+
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+
+ ArtifactDefinition artifactInfo = addArtifactToService(userId, serviceId, "install_apache");
+
+ assertEquals("add informational artifact version : " + artifactInfo.getArtifactVersion(), "1",
+ artifactInfo.getArtifactVersion());
+
+ assertNotNull("add informational artifact version : " + artifactInfo.getArtifactUUID(),
+ artifactInfo.getArtifactUUID());
+
+ Either<Service, StorageOperationStatus> service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ Map<String, ArtifactDefinition> artifacts = service.left().value().getArtifacts();
+ for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
+ String artifactId = entry.getValue().getUniqueId();
+ String description = entry.getValue().getDescription();
+
+ artifactOperation.removeArifactFromResource(serviceId, artifactId, NodeTypeEnum.Service, true, false);
+ }
+ service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ artifacts = service.left().value().getArtifacts();
+ assertEquals(0, artifacts.size());
+
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation.deleteService(serviceId);
+
+ Either<List<ArtifactData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef,
+ null, ArtifactData.class);
+ assertTrue(byCriteria.isRight());
+ assertEquals(TitanOperationStatus.NOT_FOUND, byCriteria.right().value());
+
+ serviceOperation.deleteService(serviceAfterSave.getUniqueId());
+
+ }
+
+// @Test
+ public void testUpdateArtifactToServiceVersionNotChanged() {
+ CategoryDefinition category = new CategoryDefinition();
+ category.setName(CATEGORY_NAME);
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+
+ ArtifactDefinition artifactInfo = addArtifactToService(userId, serviceId, "install_apache");
+
+ String version = artifactInfo.getArtifactVersion();
+ String artUuid = artifactInfo.getArtifactUUID();
+ assertEquals("add informational artifact version : " + version, "1", version);
+
+ artifactInfo.setDescription("jghlsk new desfnjdh");
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.updateArifactOnResource(
+ artifactInfo, serviceId, artifactInfo.getUniqueId(), NodeTypeEnum.Service, false);
+ String newVersion = artifact.left().value().getArtifactVersion();
+ String newArtUuid = artifactInfo.getArtifactUUID();
+ assertEquals("add informational artifact version : " + newVersion, newVersion, version);
+ assertEquals("add informational artifact uuid : " + newArtUuid, newArtUuid, artUuid);
+
+ Either<Service, StorageOperationStatus> service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ Map<String, ArtifactDefinition> artifacts = service.left().value().getArtifacts();
+ for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
+ String artifactId = entry.getValue().getUniqueId();
+ String description = entry.getValue().getDescription();
+
+ artifactOperation.removeArifactFromResource(serviceId, artifactId, NodeTypeEnum.Service, true, false);
+ }
+ service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ artifacts = service.left().value().getArtifacts();
+ assertEquals(0, artifacts.size());
+
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation.deleteService(serviceId);
+
+ Either<List<ArtifactData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef,
+ null, ArtifactData.class);
+ assertTrue(byCriteria.isRight());
+ assertEquals(TitanOperationStatus.NOT_FOUND, byCriteria.right().value());
+
+ serviceOperation.deleteService(serviceAfterSave.getUniqueId());
+
+ }
+
+ @Test
+ public void testCreateDeleteArtifactWithHeatParams() {
+
+ ArtifactDefinition artifactWithHeat = createResourceWithHeat();
+
+ List<HeatParameterDefinition> heatParameters = artifactWithHeat.getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+ HeatParameterDefinition parameter = heatParameters.get(0);
+ HeatParameterData parameterData = new HeatParameterData(parameter);
+ Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(),
+ parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNode.isLeft());
+
+ Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(
+ RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
+ assertTrue(removeArifact.isLeft());
+
+ ArtifactData artifactData = new ArtifactData(artifactWithHeat);
+ Either<ArtifactData, TitanOperationStatus> artifactAfterDelete = titanDao.getNode(artifactData.getUniqueIdKey(),
+ artifactData.getUniqueId(), ArtifactData.class);
+ assertTrue(artifactAfterDelete.isRight());
+
+ Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao
+ .getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNodeAfterDelete.isRight());
+
+ titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
+ }
+
+ @Test
+ public void testUpdateArtifactWithHeatParams() {
+
+ ArtifactDefinition artifactWithHeat = createResourceWithHeat();
+
+ List<HeatParameterDefinition> heatParameters = artifactWithHeat.getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+ HeatParameterDefinition parameter = heatParameters.get(0);
+ HeatParameterData parameterData = new HeatParameterData(parameter);
+ Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(),
+ parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNode.isLeft());
+
+ // update to artifact without params
+ ArtifactDefinition artifactNoParams = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
+ artifactNoParams.setUniqueId(artifactWithHeat.getUniqueId());
+ artifactNoParams.setArtifactType("HEAT");
+ artifactNoParams.setArtifactVersion("2");
+ artifactNoParams.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+
+ Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(
+ artifactNoParams, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertTrue(updateArifact.isLeft());
+
+ ArtifactData artifactData = new ArtifactData(artifactWithHeat);
+ Either<ArtifactData, TitanOperationStatus> artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(),
+ artifactData.getUniqueId(), ArtifactData.class);
+ assertTrue(artifactAfterUpdate.isLeft());
+ ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
+ assertTrue(artifactNoParams.getArtifactVersion()
+ .equals(artifactAfterUpdateValue.getArtifactDataDefinition().getArtifactVersion()));
+
+ Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao
+ .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);
+ }
+
+ @Test
+ public void testUpdateArtifactMetadataWithHeatParams() {
+
+ ArtifactDefinition artifactWithHeat = createResourceWithHeat();
+
+ List<HeatParameterDefinition> heatParameters = artifactWithHeat.getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+ HeatParameterDefinition parameter = heatParameters.get(0);
+ HeatParameterData parameterData = new HeatParameterData(parameter);
+ Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(),
+ parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNode.isLeft());
+
+ // update to artifact without params
+ artifactWithHeat.setArtifactVersion("2");
+ artifactWithHeat.setArtifactChecksum(null);
+ artifactWithHeat.setPayloadData(null);
+
+ Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(
+ artifactWithHeat, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertTrue(updateArifact.isLeft());
+
+ ArtifactData artifactData = new ArtifactData(artifactWithHeat);
+ Either<ArtifactData, TitanOperationStatus> artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(),
+ artifactData.getUniqueId(), ArtifactData.class);
+ assertTrue(artifactAfterUpdate.isLeft());
+ ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
+ assertTrue(artifactWithHeat.getArtifactVersion()
+ .equals(artifactAfterUpdateValue.getArtifactDataDefinition().getArtifactVersion()));
+
+ Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao
+ .getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNodeAfterDelete.isLeft());
+
+ Either<ArtifactDefinition, StorageOperationStatus> 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);
+
+ }
+
+ @Test
+ public void updateHeatArtifactWithTwoResources() {
+ ArtifactDefinition artifactWithHeat = createResourceWithHeat();
+
+ ResourceMetadataData resource2 = createResource(RESOURCE_ID_2);
+ Map<String, Object> props = new HashMap<String, Object>();
+ props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name());
+ Either<GraphRelation, TitanOperationStatus> createRelation = titanDao.createRelation(resource2,
+ new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props);
+ assertTrue(createRelation.isLeft());
+
+ List<HeatParameterDefinition> heatParameters = artifactWithHeat.getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+ HeatParameterDefinition parameter = heatParameters.get(0);
+ HeatParameterData parameterData = new HeatParameterData(parameter);
+ Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(),
+ parameterData.getUniqueId(), HeatParameterData.class);
+ assertTrue(parameterNode.isLeft());
+
+ ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat);
+
+ // update to artifact without params
+ atifactToUpdate.setArtifactVersion("2");
+ atifactToUpdate.setArtifactChecksum(null);
+ atifactToUpdate.setPayloadData(null);
+
+ HeatParameterDefinition heatParamUpdate = new HeatParameterDefinition(parameter);
+ List<HeatParameterDefinition> heatParametersUpdated = new ArrayList<HeatParameterDefinition>();
+ heatParamUpdate.setCurrentValue("55");
+ heatParametersUpdated.add(heatParamUpdate);
+ atifactToUpdate.setHeatParameters(heatParametersUpdated);
+
+ Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(
+ atifactToUpdate, RESOURCE_ID_2, atifactToUpdate.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertTrue(updateArifact.isLeft());
+
+ // verify old artifact and parameter still exist
+ ArtifactData artifactData = new ArtifactData(artifactWithHeat);
+ Either<ArtifactData, TitanOperationStatus> origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(),
+ artifactData.getUniqueId(), ArtifactData.class);
+ assertTrue(origArtifact.isLeft());
+ ArtifactData origArtifactData = origArtifact.left().value();
+ assertTrue(artifactWithHeat.getArtifactVersion()
+ .equals(origArtifactData.getArtifactDataDefinition().getArtifactVersion()));
+
+ Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao
+ .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<ArtifactData, TitanOperationStatus> updatedArtifact = titanDao
+ .getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
+ assertTrue(updatedArtifact.isLeft());
+ ArtifactData updatedArtifactData = updatedArtifact.left().value();
+ assertTrue(atifactToUpdate.getArtifactVersion()
+ .equals(updatedArtifactData.getArtifactDataDefinition().getArtifactVersion()));
+ assertFalse(
+ ((String) updatedArtifactData.getUniqueId()).equalsIgnoreCase((String) origArtifactData.getUniqueId()));
+
+ List<HeatParameterDefinition> heatParametersAfterUpdate = artifactDefinitionUpdated.getHeatParameters();
+ assertNotNull(heatParametersAfterUpdate);
+ assertTrue(heatParametersAfterUpdate.size() == 1);
+ HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0);
+ assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase((String) parameterData.getUniqueId()));
+ Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterUpdate = titanDao.getNode(
+ new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(),
+ HeatParameterData.class);
+ assertTrue(parameterNodeAfterUpdate.isLeft());
+
+ // delete new artifact
+ Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(
+ RESOURCE_ID_2, artifactDefinitionUpdated.getUniqueId(), NodeTypeEnum.Resource, true, false);
+ assertTrue(removeArifact.isLeft());
+
+ // verify old artifact and parameter still exist
+ origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
+ assertTrue(origArtifact.isLeft());
+ origArtifactData = origArtifact.left().value();
+ assertTrue(artifactWithHeat.getArtifactVersion()
+ .equals(origArtifactData.getArtifactDataDefinition().getArtifactVersion()));
+
+ parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(),
+ HeatParameterData.class);
+ assertTrue(parameterNodeAfterDelete.isLeft());
+
+ // verify new artifact is deleted
+ Either<ArtifactData, TitanOperationStatus> artifactAfterDelete = titanDao
+ .getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
+ assertTrue(artifactAfterDelete.isRight());
+
+ parameterNodeAfterDelete = titanDao.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);
+ }
+
+ private ArtifactDefinition createResourceWithHeat() {
+ ResourceMetadataData resource = createResource(RESOURCE_ID);
+ ArtifactDefinition artifactDefinition = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
+ artifactDefinition.setArtifactType("HEAT");
+ artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+
+ List<HeatParameterDefinition> heatParams = new ArrayList<HeatParameterDefinition>();
+ HeatParameterDefinition heatParam = new HeatParameterDefinition();
+ heatParam.setCurrentValue("11");
+ heatParam.setDefaultValue("22");
+ heatParam.setDescription("desc");
+ heatParam.setName("myParam");
+ heatParam.setType("number");
+ heatParams.add(heatParam);
+ artifactDefinition.setHeatParameters(heatParams);
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation
+ .addArifactToComponent(artifactDefinition, RESOURCE_ID, NodeTypeEnum.Resource, true, false);
+ assertTrue(artifact.isLeft());
+ ArtifactDefinition artifactWithHeat = artifact.left().value();
+ return artifactWithHeat;
+ }
+
+ private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
+ ArtifactDefinition artifactInfo = createArtifactDefinition(userId, serviceId, artifactName);
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation
+ .addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
+ assertTrue(artifact.isLeft());
+ return artifact.left().value();
+ }
+
+ private ArtifactDefinition createArtifactDefinition(String userId, String serviceId, String artifactName) {
+ ArtifactDefinition artifactInfo = new ArtifactDefinition();
+
+ artifactInfo.setArtifactName(artifactName + ".sh");
+ artifactInfo.setArtifactType("SHELL");
+ artifactInfo.setDescription("hdkfhskdfgh");
+ artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
+
+ artifactInfo.setUserIdCreator(userId);
+ String fullName = "Jim H";
+ artifactInfo.setUpdaterFullName(fullName);
+ long time = System.currentTimeMillis();
+ artifactInfo.setCreatorFullName(fullName);
+ artifactInfo.setCreationDate(time);
+ artifactInfo.setLastUpdateDate(time);
+ artifactInfo.setUserIdLastUpdater(userId);
+ artifactInfo.setArtifactLabel(artifactName);
+ artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
+ return artifactInfo;
+ }
+
+ public Service createService(String userId, CategoryDefinition category, String serviceName, String serviceVersion,
+ boolean isHighestVersion) {
+
+ Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
+
+ service.setHighestVersion(isHighestVersion);
+
+ Either<Service, StorageOperationStatus> result = serviceOperation.createService(service, true);
+
+ log.info(result.toString());
+ assertTrue(result.isLeft());
+ Service resultService = result.left().value();
+
+ // assertEquals("check resource unique id",
+ // UniqueIdBuilder.buildServiceUniqueId(serviceName, serviceVersion),
+ // resultService.getUniqueId());
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultService.getLifecycleState());
+
+ return resultService;
+ }
+
+ private Service buildServiceMetadata(String userId, CategoryDefinition category, String serviceName,
+ String serviceVersion) {
+
+ Service service = new Service();
+ service.setName(serviceName);
+ service.setVersion(serviceVersion);
+ service.setDescription("description 1");
+
+ service.setCreatorUserId(userId);
+ service.setContactId("contactId@sdc.com");
+ List<CategoryDefinition> categories = new ArrayList<>();
+ categories.add(category);
+ service.setCategories(categories);
+ service.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ service.setTags(tags);
+ return service;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao);
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+ if (role != null && !role.isEmpty()) {
+ userData.setRole(role);
+ } else {
+ userData.setRole("ADMIN");
+ }
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ public ResourceMetadataData createResource(String resourceName) {
+
+ ResourceMetadataData serviceData1 = new ResourceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
+ Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.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
new file mode 100644
index 0000000000..5b8420d5dc
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.java
@@ -0,0 +1,345 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import javax.annotation.Resource;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.config.Configuration;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.common.api.ConfigurationListener;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+// @TestExecutionListeners(listeners = {
+// DependencyInjectionTestExecutionListener.class,
+// DirtiesContextTestExecutionListener.class,
+// TransactionalTestExecutionListener.class })
+public class CapabilityTypeOperationTest extends ModelTestBase {
+
+ @Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ // ExternalConfiguration.setAppName("catalog-model");
+ // String appConfigDir = "src/test/resources/config/catalog-model";
+ // ConfigurationSource configurationSource = new
+ // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ // appConfigDir);
+
+ // configurationManager = new ConfigurationManager(
+ // new ConfigurationSource() {
+ //
+ // @Override
+ // public <T> T getAndWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+ //
+ // @Override
+ // public <T> void addWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ //
+ // }
+ // });
+ //
+ // Configuration configuration = new Configuration();
+ // configuration.setTitanInMemoryGraph(true);
+ //
+ // configurationManager.setConfiguration(configuration);
+ ModelTestBase.init();
+
+ }
+
+ @Test
+ public void testDummy() {
+
+ assertTrue(capabilityTypeOperation != null);
+
+ }
+
+ @Test
+ public void testAddCapabilityType() {
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setDescription("desc1");
+ capabilityTypeDefinition.setType("tosca.capabilities.Container1");
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition, true);
+ assertEquals("check capability type added", true, addCapabilityType1.isLeft());
+
+ CapabilityTypeDefinition capabilityTypeAdded = addCapabilityType1.left().value();
+ compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
+
+ Either<CapabilityTypeDefinition, TitanOperationStatus> capabilityTypeByUid = capabilityTypeOperation
+ .getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId());
+ compareBetweenCreatedToSent(capabilityTypeByUid.left().value(), capabilityTypeDefinition);
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType2 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition, true);
+ assertEquals("check capability type failed", true, addCapabilityType2.isRight());
+ assertEquals("check returned error", StorageOperationStatus.SCHEMA_VIOLATION,
+ addCapabilityType2.right().value());
+
+ }
+
+ @Test
+ public void testAddDerviedCapabilityType() {
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setDescription("desc1");
+ capabilityTypeDefinition.setType("tosca.capabilities.Container2");
+ capabilityTypeDefinition.setDerivedFrom("derivedFrom");
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition, true);
+ // assertEquals("check capability type parent not exist",
+ // StorageOperationStatus.INVALID_ID,
+ // addCapabilityType1.right().value());
+ // TODO: esofer change to INVALID_ID
+ assertEquals("check capability type parent not exist", StorageOperationStatus.INVALID_ID,
+ addCapabilityType1.right().value());
+ }
+
+ public CapabilityTypeDefinition createCapability(String capabilityTypeName) {
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setDescription("desc1");
+ capabilityTypeDefinition.setType(capabilityTypeName);
+
+ Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
+
+ String propName1 = "disk_size";
+ String propName2 = "num_cpus";
+
+ PropertyDefinition property1 = buildProperty1();
+
+ properties.put(propName1, property1);
+
+ PropertyDefinition property2 = buildProperty2();
+
+ properties.put(propName2, property2);
+
+ capabilityTypeDefinition.setProperties(properties);
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition, true);
+
+ CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
+ Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
+ .getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId(), true);
+ assertEquals("check capability type fetched", true, capabilityType.isLeft());
+ CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
+
+ Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
+
+ compareProperties(fetchedProps, properties);
+
+ return fetchedCTD;
+
+ }
+
+ @Test
+ public void testAddCapabilityTypeWithProperties() {
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setDescription("desc1");
+ capabilityTypeDefinition.setType("tosca.capabilities.Container3");
+
+ Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
+
+ String propName1 = "disk_size";
+ String propName2 = "num_cpus";
+
+ PropertyDefinition property1 = buildProperty1();
+
+ properties.put(propName1, property1);
+
+ PropertyDefinition property2 = buildProperty2();
+
+ properties.put(propName2, property2);
+
+ capabilityTypeDefinition.setProperties(properties);
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition, true);
+
+ CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
+ Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
+ .getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId());
+ assertEquals("check capability type fetched", true, capabilityType.isLeft());
+ CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
+
+ Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
+
+ compareProperties(fetchedProps, properties);
+ }
+
+ private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
+
+ assertTrue("check properties are full or empty",
+ ((first == null && second == null) || (first != null && second != null)));
+ if (first != null) {
+ assertEquals("check properties size", first.size(), second.size());
+
+ for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
+
+ String propName = entry.getKey();
+ PropertyDefinition secondPD = second.get(propName);
+ assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
+
+ PropertyDefinition firstPD = entry.getValue();
+
+ comparePropertyDefinition(firstPD, secondPD);
+ }
+
+ }
+
+ }
+
+ @Test
+ public void testGetCapabilityTypeNotFound() {
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
+ .getCapabilityType("not_exists");
+ assertEquals("check not found is returned", StorageOperationStatus.NOT_FOUND, capabilityType.right().value());
+
+ }
+
+ private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
+
+ assertTrue("check objects are full or empty",
+ ((first == null && second == null) || (first != null && second != null)));
+ if (first != null) {
+ assertTrue("check property default value", compareValue(first.getDefaultValue(), second.getDefaultValue()));
+ assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
+ assertTrue("check property type", compareValue(first.getType(), second.getType()));
+ compareList(first.getConstraints(), second.getConstraints());
+ }
+
+ }
+
+ private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
+
+ assertTrue("check lists are full or empty",
+ ((first == null && second == null) || (first != null && second != null)));
+ if (first != null) {
+ assertEquals("check list size", first.size(), second.size());
+ }
+ }
+
+ private PropertyDefinition buildProperty2() {
+ PropertyDefinition property2 = new PropertyDefinition();
+ property2.setDefaultValue("2");
+ property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
+ property2.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
+ List<String> range = new ArrayList<String>();
+ range.add("1");
+ range.add("4");
+
+ InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
+ constraints3.add(propertyConstraint3);
+ // property2.setConstraints(constraints3);
+ property2.setConstraints(constraints3);
+ return property2;
+ }
+
+ private PropertyDefinition buildProperty1() {
+ PropertyDefinition property1 = new PropertyDefinition();
+ property1.setDefaultValue("10");
+ property1.setDescription(
+ "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
+ property1.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
+ GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
+ constraints.add(propertyConstraint1);
+
+ LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
+ constraints.add(propertyConstraint2);
+
+ property1.setConstraints(constraints);
+ return property1;
+ }
+
+ private void compareBetweenCreatedToSent(CapabilityTypeDefinition x, CapabilityTypeDefinition y) {
+
+ assertTrue(compareValue(x.getDerivedFrom(), y.getDerivedFrom()));
+ assertTrue(compareValue(x.getType(), y.getType()));
+ assertTrue(compareValue(x.getDescription(), y.getDescription()));
+
+ }
+
+ public boolean compareValue(String first, String second) {
+
+ if (first == null && second == null) {
+ return true;
+ }
+ if (first != null) {
+ return first.equals(second);
+ } else {
+ return false;
+ }
+ }
+
+ public void setOperations(TitanGenericDao titanDao, CapabilityTypeOperation capabilityTypeOperation) {
+ this.titanDao = titanDao;
+ this.capabilityTypeOperation = capabilityTypeOperation;
+
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationSpringTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationSpringTest.java
new file mode 100644
index 0000000000..2dcb1ee72e
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationSpringTest.java
@@ -0,0 +1,543 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import javax.annotation.Resource;
+
+import org.apache.tinkerpop.gremlin.structure.io.IoCore;
+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.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.LifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.operations.impl.util.ResourceCreationUtils;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.be.resources.data.CapabilityData;
+import org.openecomp.sdc.be.resources.data.CapabilityInstData;
+import org.openecomp.sdc.be.resources.data.PropertyValueData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.be.unittests.utils.FactoryUtils;
+import org.openecomp.sdc.be.unittests.utils.FactoryUtils.Constants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ComponentInstanceOperationSpringTest extends ModelTestBase {
+ private static Logger log = LoggerFactory.getLogger(ComponentInstanceOperationSpringTest.class.getName());
+ @Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation componentInstanceOperation;
+
+ @Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation resourceInstanceOperation;
+
+ @Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @Resource(name = "capability-operation")
+ public CapabilityOperation capabilityOperation;
+
+ @Resource(name = "service-operation")
+ private ServiceOperation serviceOperation;
+
+ @Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @Resource(name = "lifecycle-operation")
+ private LifecycleOperation lifecycleOperation;
+
+ TitanGenericDao titanGenericDao;
+
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ User rfcUser;
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ ModelTestBase.init();
+
+ }
+
+ @Before
+ public void cleanUp() {
+ titanGenericDao = componentInstanceOperation.titanGenericDao;
+ Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
+ TitanGraph graph = graphResult.left().value();
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ TitanVertex vertex = iterator.next();
+ vertex.remove();
+ }
+
+ }
+ titanGenericDao.commit();
+ deleteAndCreateCategory(CATEGORY_NAME);
+ UserData modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "rfc",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
+ rfcUser = convertUserDataToUser(modifierData);
+ }
+
+ @Test
+ public void testAddCapabilityPropertyValuesToResourceInstance() {
+ String rootName = "Root123";
+ org.openecomp.sdc.be.model.Resource rootResource = createResource(rfcUser.getUserId(), CATEGORY_NAME, rootName,
+ "1.0", null, false, true);
+
+ // certification request
+ Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> requestCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, rootResource, rfcUser, rfcUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ org.openecomp.sdc.be.model.Resource resultResource = (org.openecomp.sdc.be.model.Resource) requestCertificationResult
+ .left().value();
+
+ // start certification
+ Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Resource, resultResource, rfcUser, rfcUser, false);
+ assertEquals(true, startCertificationResult.isLeft());
+
+ Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> certifiedResourceRes = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Resource, rootResource, rfcUser, rfcUser, false);
+ assertTrue(certifiedResourceRes.isLeft());
+
+ CapabilityTypeDefinition capabilityType = buildCapabilityType();
+ Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityTypeRes = capabilityTypeOperation
+ .addCapabilityType(capabilityType);
+ assertTrue(capabilityTypeRes.isLeft());
+
+ CapabilityData capData = FactoryUtils.createCapabilityData();
+ CapabilityDefinition capabilityDefinitionRoot = FactoryUtils
+ .convertCapabilityDataToCapabilityDefinitionRoot(capData);
+
+ Either<CapabilityDefinition, StorageOperationStatus> addCapabilityRootRes = capabilityOperation.addCapability(
+ (String) certifiedResourceRes.left().value().getUniqueId(), capabilityDefinitionRoot.getName(),
+ capabilityDefinitionRoot);
+ assertTrue(addCapabilityRootRes.isLeft());
+
+ String resourceName = "tosca.nodes.Apache.2.0";
+
+ CapabilityDefinition capabilityDefinition = FactoryUtils
+ .convertCapabilityDataToCapabilityDefinitionAddProperties(capData);
+ org.openecomp.sdc.be.model.Resource resource = createResource(rfcUser.getUserId(), CATEGORY_NAME, resourceName,
+ "0.1", rootName, false, true);
+
+ Either<CapabilityDefinition, StorageOperationStatus> addCapabilityRes = capabilityOperation
+ .addCapability((String) resource.getUniqueId(), capabilityDefinition.getName(), capabilityDefinition);
+ assertTrue(addCapabilityRes.isLeft());
+ List<ComponentInstanceProperty> properties = addCapabilityRes.left().value().getProperties();
+ assertTrue(properties.size() == 2);
+
+ Either<org.openecomp.sdc.be.model.Resource, StorageOperationStatus> clonedResourceRes = resourceOperation
+ .cloneComponent(resource, "0.2", false);
+ assertTrue(clonedResourceRes.isLeft());
+ org.openecomp.sdc.be.model.Resource clonedResource = clonedResourceRes.left().value();
+
+ ComponentInstance instance = buildResourceInstance(clonedResource.getUniqueId(), "1", "tosca.nodes.Apache");
+
+ Service origService = createService(rfcUser.getUserId(), CATEGORY_NAME, "my-service", "1.0", true);
+ Either<Service, StorageOperationStatus> service2 = serviceOperation.getService(origService.getUniqueId(),
+ false);
+ assertTrue(service2.isLeft());
+ origService = service2.left().value();
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(origService);
+ log.debug(json);
+
+ Service fullService = origService;
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent((String) origService.getUniqueId(), NodeTypeEnum.Service, "1",
+ true, instance, NodeTypeEnum.Resource, false);
+ assertTrue(status.isLeft());
+
+ ComponentInstance resourceInstance = status.left().value();
+ CapabilityDefinition capability = addCapabilityRes.left().value();
+ capability.setName(capabilityDefinition.getName());
+ List<ComponentInstanceProperty> propertyValues = FactoryUtils.createComponentInstancePropertyList();
+ capability.setProperties(propertyValues);
+
+ Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> addCPVsToRiRes = componentInstanceOperation
+ .addCapabilityPropertyValuesToResourceInstance(resourceInstance.getUniqueId(), capability, true);
+ assertTrue(addCPVsToRiRes.isLeft());
+
+ Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0",
+ false);
+ assertTrue(createService.isLeft());
+ Map<String, List<CapabilityDefinition>> capabilitiesMap = createService.left().value().getCapabilities();
+ assertTrue(capabilitiesMap != null && capabilitiesMap.size() == 1);
+ Map<String, CapabilityDefinition> capabilities = capabilitiesMap.values().iterator().next().stream()
+ .collect(Collectors.toMap(CapabilityDefinition::getName, Function.identity()));
+ assertTrue(capabilities.containsKey("Cap1") && capabilities.containsKey("Cap2"));
+
+ // String outputFile = exportGraphMl();
+
+ }
+
+ public String exportGraphMl() {
+ String result = null;
+ String outputFile = "C:\\Output" + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
+ TitanGraph graph = titanGenericDao.getGraph().left().value();
+ 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;
+
+ }
+
+ private CapabilityTypeDefinition buildCapabilityType() {
+ CapabilityTypeDefinition capabilityType = new CapabilityTypeDefinition();
+ Map<String, PropertyDefinition> properties = new HashMap();
+
+ capabilityType.setType(Constants.DEFAULT_CAPABILITY_TYPE);
+ capabilityType.setProperties(properties);
+
+ PropertyDefinition host = new PropertyDefinition();
+ host.setUniqueId(UUID.randomUUID().toString());
+ host.setName("host");
+ host.setDefaultValue("captypehost");
+ host.setType("string");
+
+ host.setSchema(new SchemaDefinition());
+ host.getSchema().setProperty(new PropertyDataDefinition());
+ host.getSchema().getProperty().setType("string");
+
+ PropertyDefinition port = new PropertyDefinition();
+ port.setName("port");
+ port.setDefaultValue("captypeport");
+ port.setUniqueId(UUID.randomUUID().toString());
+ port.setType("string");
+
+ port.setSchema(new SchemaDefinition());
+ port.getSchema().setProperty(new PropertyDataDefinition());
+ port.getSchema().getProperty().setType("string");
+
+ PropertyDefinition rootproperty = new PropertyDefinition();
+ rootproperty.setName("captypeproperty");
+ rootproperty.setDefaultValue("captypevalue");
+ rootproperty.setUniqueId(UUID.randomUUID().toString());
+ rootproperty.setType("string");
+
+ rootproperty.setSchema(new SchemaDefinition());
+ rootproperty.getSchema().setProperty(new PropertyDataDefinition());
+ rootproperty.getSchema().getProperty().setType("string");
+
+ properties.put("host", host);
+ properties.put("port", port);
+ properties.put("captypeproperty", rootproperty);
+ return capabilityType;
+ }
+
+ private CapabilityInstData buildCapabilityInstanceData(String resourceInstanceId, CapabilityDefinition capability) {
+ CapabilityInstData capabilityInstance = new CapabilityInstData();
+ Long creationTime = System.currentTimeMillis();
+ String uniqueId = UniqueIdBuilder.buildCapabilityInstanceUid(resourceInstanceId, capability.getName());
+ capabilityInstance.setCreationTime(creationTime);
+ capabilityInstance.setModificationTime(creationTime);
+ capabilityInstance.setUniqueId(uniqueId);
+ return capabilityInstance;
+ }
+
+ private ComponentInstance buildResourceInstance(String respurceUid, String instanceNumber, String name) {
+ ComponentInstance resourceInstance = new ComponentInstance();
+ resourceInstance.setName(name);
+ resourceInstance.setDescription("desc1");
+ resourceInstance.setPosX("20");
+ resourceInstance.setPosY("40");
+ resourceInstance.setComponentUid(respurceUid);
+ resourceInstance.setCreationTime(System.currentTimeMillis());
+ resourceInstance.setModificationTime(System.currentTimeMillis());
+ resourceInstance.setNormalizedName(ResourceInstanceOperationTest.normaliseComponentInstanceName(name));
+ return resourceInstance;
+ }
+
+ public ResourceMetadataData createResource(String resourceName, TitanGenericDao titanGenericDao) {
+ ResourceMetadataData serviceData1 = new ResourceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
+ Either<ResourceMetadataData, TitanOperationStatus> createNode = titanGenericDao.createNode(serviceData1,
+ ResourceMetadataData.class);
+ assertTrue("check service created", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ public ServiceMetadataData createServiceMetadataData(String serviceName, TitanGenericDao titanGenericDao) {
+ ServiceMetadataData serviceData1 = new ServiceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
+ Either<ServiceMetadataData, TitanOperationStatus> createNode = titanGenericDao.createNode(serviceData1,
+ ServiceMetadataData.class);
+ assertTrue("check service created", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ public Service createService(String userId, String category, String serviceName, String serviceVersion,
+ boolean isHighestVersion) {
+ Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
+ service.setHighestVersion(isHighestVersion);
+ Either<Service, StorageOperationStatus> result = serviceOperation.createService(service, true);
+ assertTrue(result.isLeft());
+ Service resultService = result.left().value();
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultService.getLifecycleState());
+ return resultService;
+ }
+
+ private Service buildServiceMetadata(String userId, String category, String serviceName, String serviceVersion) {
+ Service service = new Service();
+ service.setName(serviceName);
+ service.setVersion(serviceVersion);
+ service.setDescription("description 1");
+ service.setCreatorUserId(userId);
+ service.setContactId("contactId@sdc.com");
+ CategoryDefinition categoryDef = new CategoryDefinition();
+ categoryDef.setName(category);
+ List<CategoryDefinition> categories = new ArrayList<>();
+ categories.add(categoryDef);
+ service.setCategories(categories);
+ service.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ service.setTags(tags);
+ return service;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateServiceCategory(category, titanGenericDao);
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanGenericDao);
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+ if (role != null && !role.isEmpty()) {
+ userData.setRole(role);
+ } else {
+ userData.setRole("ADMIN");
+ }
+ titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanGenericDao.createNode(userData, UserData.class);
+ titanGenericDao.commit();
+ return userData;
+ }
+
+ public org.openecomp.sdc.be.model.Resource createResource(String userId, String category, String resourceName,
+ String resourceVersion, String parentResourceName, boolean isAbstract, boolean isHighestVersion) {
+
+ String propName1 = "disk_size";
+ String propName2 = "num_cpus";
+
+ List<String> derivedFrom = new ArrayList<String>();
+ if (parentResourceName != null) {
+ derivedFrom.add(parentResourceName);
+ }
+ org.openecomp.sdc.be.model.Resource resource = buildResourceMetadata(userId, category, resourceName,
+ resourceVersion);
+
+ resource.setAbstract(isAbstract);
+ resource.setHighestVersion(isHighestVersion);
+
+ Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
+
+ PropertyDefinition property1 = new PropertyDefinition();
+ property1.setDefaultValue("10");
+ property1.setDescription(
+ "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
+ property1.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
+ GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
+ log.debug("{}", propertyConstraint1);
+
+ constraints.add(propertyConstraint1);
+
+ LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
+ constraints.add(propertyConstraint2);
+
+ property1.setConstraints(constraints);
+
+ properties.put(propName1, property1);
+
+ PropertyDefinition property2 = new PropertyDefinition();
+ property2.setDefaultValue("2");
+ property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
+ property2.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
+ List<String> range = new ArrayList<String>();
+ range.add("1");
+ range.add("4");
+
+ InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
+ constraints3.add(propertyConstraint3);
+ property2.setConstraints(constraints3);
+ properties.put(propName2, property2);
+
+ resource.setDerivedFrom(derivedFrom);
+
+ resource.setProperties(convertMapToList(properties));
+
+ Either<org.openecomp.sdc.be.model.Resource, StorageOperationStatus> result = resourceOperation
+ .createResource(resource, true);
+
+ assertTrue(result.isLeft());
+ org.openecomp.sdc.be.model.Resource resultResource = result.left().value();
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultResource.getLifecycleState());
+
+ String resourceId = resultResource.getUniqueId();
+
+ Either<PropertyDefinition, StorageOperationStatus> either = propertyOperation.getPropertyOfResource(propName1,
+ resourceId);
+
+ assertTrue(either.isLeft());
+ PropertyDefinition propertyDefinition = either.left().value();
+ assertEquals("check property default value", property1.getDefaultValue(), propertyDefinition.getDefaultValue());
+ assertEquals("check property description", property1.getDescription(), propertyDefinition.getDescription());
+ assertEquals("check property type", property1.getType(), propertyDefinition.getType());
+ assertEquals("check property unique id", property1.getUniqueId(), propertyDefinition.getUniqueId());
+ assertEquals("check property consitraints size", property1.getConstraints().size(),
+ propertyDefinition.getConstraints().size());
+
+ return resultResource;
+ }
+
+ private org.openecomp.sdc.be.model.Resource buildResourceMetadata(String userId, String category,
+ String resourceName, String resourceVersion) {
+
+ org.openecomp.sdc.be.model.Resource resource = new org.openecomp.sdc.be.model.Resource();
+ resource.setName(resourceName);
+ resource.setVersion(resourceVersion);
+ ;
+ resource.setDescription("description 1");
+ resource.setAbstract(false);
+ resource.setCreatorUserId(userId);
+ resource.setContactId("contactId@sdc.com");
+ resource.setVendorName("vendor 1");
+ resource.setVendorRelease("1.0.0");
+ resource.setToscaResourceName(resourceName);
+ String[] categoryArr = category.split("/");
+ resource.addCategory(categoryArr[0], categoryArr[1]);
+ resource.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ resource.setTags(tags);
+ return resource;
+ }
+
+ public static List<PropertyDefinition> convertMapToList(Map<String, PropertyDefinition> properties) {
+ if (properties == null) {
+ return null;
+ }
+
+ List<PropertyDefinition> definitions = new ArrayList<>();
+ for (Entry<String, PropertyDefinition> entry : properties.entrySet()) {
+ String name = entry.getKey();
+ PropertyDefinition propertyDefinition = entry.getValue();
+ propertyDefinition.setName(name);
+ definitions.add(propertyDefinition);
+ }
+
+ return definitions;
+ }
+
+ private User convertUserDataToUser(UserData modifierData) {
+ User modifier = new User();
+ modifier.setUserId(modifierData.getUserId());
+ modifier.setEmail(modifierData.getEmail());
+ modifier.setFirstName(modifierData.getFirstName());
+ modifier.setLastName(modifierData.getLastName());
+ modifier.setRole(modifierData.getRole());
+ return modifier;
+ }
+}
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
new file mode 100644
index 0000000000..e77c9f0291
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperationTest.java
@@ -0,0 +1,136 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
+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.CapabilityDefinition;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.CapabilityData;
+import org.openecomp.sdc.be.resources.data.CapabilityInstData;
+import org.openecomp.sdc.be.resources.data.RequirementData;
+import org.openecomp.sdc.be.unittests.utils.FactoryUtils;
+
+import fj.data.Either;
+
+public class ComponentInstanceOperationTest {
+
+ @InjectMocks
+ ComponentInstanceOperation componentInstanceOperation = new ComponentInstanceOperation();
+ @InjectMocks
+ private TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
+
+ @Before
+ public void beforeTest() {
+ Mockito.reset(titanGenericDao);
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void testGetCapabilities() {
+
+ ComponentInstance ri = FactoryUtils.createResourceInstance();
+ CapabilityData capData = FactoryUtils.createCapabilityData();
+ Either<List<ImmutablePair<GraphNode, GraphEdge>>, TitanOperationStatus> childNodesReturned = prepareChildNodeRetValue(
+ capData);
+
+ Mockito.when(titanGenericDao.getChildrenNodes(Mockito.anyString(), Mockito.anyString(),
+ Mockito.any(GraphEdgeLabels.class), Mockito.any(NodeTypeEnum.class), Mockito.any()))
+ .thenReturn(childNodesReturned);
+
+ // ImmutablePair<ComponentInstance, List<ImmutablePair<CapabilityData,
+ // GraphEdge>>> instanceAndCapabilities =
+ // componentInstanceOperation.getCapabilities(ri,
+ // NodeTypeEnum.Resource);
+
+ Either<List<ImmutablePair<CapabilityData, GraphEdge>>, TitanOperationStatus> instanceAndCapabilities = componentInstanceOperation
+ .getCapabilities(ri, NodeTypeEnum.Resource);
+
+ // assertTrue(instanceAndCapabilities.left.getUniqueId().equals(ri.getUniqueId()));
+ assertTrue(instanceAndCapabilities.left().value().size() == 1);
+ assertTrue(instanceAndCapabilities.left().value().get(0).left.getUniqueId().equals(capData.getUniqueId()));
+
+ }
+
+ @Test
+ public void testGetRequirements() {
+ ComponentInstance ri = FactoryUtils.createResourceInstance();
+ RequirementData reqData = FactoryUtils.createRequirementData();
+ Either<List<ImmutablePair<GraphNode, GraphEdge>>, TitanOperationStatus> childNodesReturned = prepareChildNodeRetValue(
+ reqData);
+
+ Mockito.when(titanGenericDao.getChildrenNodes(Mockito.anyString(), Mockito.anyString(),
+ Mockito.any(GraphEdgeLabels.class), Mockito.any(NodeTypeEnum.class), Mockito.any()))
+ .thenReturn(childNodesReturned);
+
+ // ImmutablePair<ComponentInstance, List<ImmutablePair<RequirementData,
+ // GraphEdge>>> instanceAndCapabilities =
+ // componentInstanceOperation.getRequirements(ri,
+ // NodeTypeEnum.Resource);
+ Either<List<ImmutablePair<RequirementData, GraphEdge>>, TitanOperationStatus> instanceAndCapabilities = componentInstanceOperation
+ .getRequirements(ri, NodeTypeEnum.Resource);
+
+ // assertTrue(instanceAndCapabilities.left.getUniqueId().equals(ri.getUniqueId()));
+ // assertTrue(instanceAndCapabilities.right.size() == 1);
+ // assertTrue(instanceAndCapabilities.right.get(0).left.getUniqueId().equals(reqData.getUniqueId()));
+
+ assertTrue(instanceAndCapabilities.left().value().size() == 1);
+ assertTrue(instanceAndCapabilities.left().value().get(0).left.getUniqueId().equals(reqData.getUniqueId()));
+
+ }
+
+ private CapabilityInstData buildCapabilityInstanceData(String resourceInstanceId, CapabilityDefinition capability) {
+ CapabilityInstData capabilityInstance = new CapabilityInstData();
+ Long creationTime = System.currentTimeMillis();
+ String uniqueId = UniqueIdBuilder.buildCapabilityInstanceUid(resourceInstanceId, capability.getName());
+
+ capabilityInstance.setCreationTime(creationTime);
+ capabilityInstance.setModificationTime(creationTime);
+ capabilityInstance.setUniqueId(uniqueId);
+
+ return capabilityInstance;
+ }
+
+ private Either<List<ImmutablePair<GraphNode, GraphEdge>>, TitanOperationStatus> prepareChildNodeRetValue(
+ GraphNode data) {
+ ImmutablePair<GraphNode, GraphEdge> pair = new ImmutablePair<>(data, FactoryUtils.createGraphEdge());
+ List<ImmutablePair<GraphNode, GraphEdge>> retList = new ArrayList<>();
+ retList.add(pair);
+ return Either.left(retList);
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentOperationTest.java
new file mode 100644
index 0000000000..14018d31f9
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ComponentOperationTest.java
@@ -0,0 +1,395 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+import com.thinkaurelius.titan.core.TitanTransaction;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+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.FilterKeyEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.operations.api.ICapabilityOperation;
+import org.openecomp.sdc.be.model.operations.api.IRequirementOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.resources.data.CapabilityData;
+import org.openecomp.sdc.be.resources.data.CapabilityInstData;
+import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
+import org.openecomp.sdc.be.resources.data.PropertyData;
+import org.openecomp.sdc.be.resources.data.PropertyValueData;
+import org.openecomp.sdc.be.resources.data.RequirementData;
+import org.openecomp.sdc.be.unittests.utils.FactoryUtils;
+
+import fj.data.Either;
+
+public class ComponentOperationTest {
+ @InjectMocks
+ ComponentOperation compOperation = getAnnonimusImpl();
+
+ ComponentInstanceOperation componentInstanceOperation = Mockito.mock(ComponentInstanceOperation.class);
+ TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
+ ICapabilityOperation capabilityOperation = Mockito.mock(ICapabilityOperation.class);
+ IRequirementOperation requirementOperation = Mockito.mock(IRequirementOperation.class);
+
+ @Before
+ public void beforeTest() {
+ Mockito.reset(componentInstanceOperation, requirementOperation, capabilityOperation);
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void testGetCapabilities() {
+ Resource vf = FactoryUtils.createVF();
+ ComponentInstance ri = FactoryUtils.createResourceInstance();
+ CapabilityData capData = FactoryUtils.createCapabilityData();
+
+ FactoryUtils.addComponentInstanceToVF(vf, ri);
+ Either<List<ImmutablePair<CapabilityData, GraphEdge>>, TitanOperationStatus> capDataList = prepareCompOperationReturnValue(
+ ri, capData);
+
+ prepareMocksForCapabilitiesMethods(ri, capDataList);
+
+ Map<String, List<CapabilityDefinition>> capabilities = compOperation
+ .getCapabilities(vf, NodeTypeEnum.Resource, false).left().value();
+ assertTrue(capabilities.size() == 1);
+ Entry<String, List<CapabilityDefinition>> entry = capabilities.entrySet().iterator().next();
+ assertTrue(entry.getKey().equals(capData.getType()));
+ assertTrue(entry.getValue().size() == 1);
+ assertTrue(entry.getValue().get(0).getUniqueId().equals(capData.getUniqueId()));
+ }
+
+ @Test
+ public void testGetRequirments() {
+ Resource vf = FactoryUtils.createVF();
+ ComponentInstance ri = FactoryUtils.createResourceInstance();
+
+ RequirementData reqData = FactoryUtils.createRequirementData();
+
+ FactoryUtils.addComponentInstanceToVF(vf, ri);
+
+ Either<List<ImmutablePair<RequirementData, GraphEdge>>, TitanOperationStatus> reqDataEdgeList = prepareCompOperationReturnValue(
+ ri, reqData);
+
+ prepareMocksForRequirmenetsMethods(ri, reqDataEdgeList);
+
+ Map<String, List<RequirementDefinition>> requirements = compOperation
+ .getRequirements(vf, NodeTypeEnum.Resource, false).left().value();
+ assertTrue(requirements.size() == 1);
+ Entry<String, List<RequirementDefinition>> entry = requirements.entrySet().iterator().next();
+ assertTrue(entry.getKey().equals(FactoryUtils.Constants.DEFAULT_CAPABILITY_TYPE));
+ assertTrue(entry.getValue().size() == 1);
+ assertTrue(entry.getValue().get(0).getUniqueId().equals(reqData.getUniqueId()));
+ }
+
+ private void prepareMocksForRequirmenetsMethods(ComponentInstance ri,
+ Either<List<ImmutablePair<RequirementData, GraphEdge>>, TitanOperationStatus> reqDataEdgeList) {
+
+ when(componentInstanceOperation.getRequirements(ri, NodeTypeEnum.Resource)).thenReturn(reqDataEdgeList);
+ when(requirementOperation.getRequirement(Mockito.anyString())).then(createReqDefAnswer());
+ }
+
+ private void prepareMocksForCapabilitiesMethods(ComponentInstance ri,
+ Either<List<ImmutablePair<CapabilityData, GraphEdge>>, TitanOperationStatus> capDataList) {
+ when(componentInstanceOperation.getCapabilities(ri, NodeTypeEnum.Resource)).thenReturn(capDataList);
+ when(capabilityOperation.getCapabilityByCapabilityData(Mockito.any(CapabilityData.class)))
+ .then(createCapDefByDataAnswer());
+ List<ImmutablePair<CapabilityInstData, GraphEdge>> capInstList = new ArrayList<>();
+ CapabilityInstData curCapabilityInst = FactoryUtils.createCapabilityInstData();
+ GraphEdge edge = new GraphEdge();
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(),
+ capDataList.left().value().get(0).getLeft().getUniqueId());
+ edge.setProperties(properties);
+ ImmutablePair<CapabilityInstData, GraphEdge> pair = new ImmutablePair<CapabilityInstData, GraphEdge>(
+ curCapabilityInst, edge);
+ capInstList.add(pair);
+ when(titanGenericDao.getChildrenNodes(
+ UniqueIdBuilder.getKeyByNodeType(
+ NodeTypeEnum.getByNameIgnoreCase(ri.getOriginType().getInstanceType().trim())),
+ ri.getUniqueId(), GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst,
+ CapabilityInstData.class)).thenReturn(Either.left(capInstList));
+
+ when(titanGenericDao.getChild(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.getByName(curCapabilityInst.getLabel())),
+ curCapabilityInst.getUniqueId(), GraphEdgeLabels.INSTANCE_OF, NodeTypeEnum.Capability,
+ CapabilityData.class)).thenReturn(Either.left(capDataList.left().value().get(0)));
+
+ PropertyValueData propertyValueData = FactoryUtils.createPropertyData();
+ ImmutablePair<PropertyValueData, GraphEdge> propPair = new ImmutablePair<PropertyValueData, GraphEdge>(
+ propertyValueData, null);
+ List<ImmutablePair<PropertyValueData, GraphEdge>> propPairList = new ArrayList<>();
+ propPairList.add(propPair);
+ when(titanGenericDao.getChildrenNodes(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.getByName(curCapabilityInst.getLabel())),
+ curCapabilityInst.getUniqueId(), GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue,
+ PropertyValueData.class)).thenReturn(Either.left(propPairList));
+
+ CapabilityDefinition capDef = FactoryUtils
+ .convertCapabilityDataToCapabilityDefinitionAddProperties(capDataList.left().value().get(0).getLeft());
+ List<PropertyDefinition> propDefList = capDef.getProperties().stream().filter(p -> p.getName().equals("host"))
+ .collect(Collectors.toList());
+ PropertyDefinition propDef = propDefList.get(0);
+ PropertyData propData = FactoryUtils.convertCapabilityDefinitionToCapabilityData(propDef);
+
+ ImmutablePair<PropertyData, GraphEdge> defPropPair = new ImmutablePair<PropertyData, GraphEdge>(propData, edge);
+
+ when(titanGenericDao.getChild(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.getByName(propertyValueData.getLabel())),
+ propertyValueData.getUniqueId(), GraphEdgeLabels.PROPERTY_IMPL, NodeTypeEnum.Property,
+ PropertyData.class)).thenReturn(Either.left(defPropPair));
+ List<CapabilityDefinition> capDefList = new ArrayList<>();
+ capDefList.add(capDef);
+ when(componentInstanceOperation.updateCapDefPropertyValues(Mockito.any(ComponentInstance.class),
+ Mockito.any(List.class))).thenReturn(Either.left(capDefList));
+ }
+
+ private <Data> Either<List<ImmutablePair<Data, GraphEdge>>, TitanOperationStatus> prepareCompOperationReturnValue(
+ ComponentInstance ri, Data data) {
+ ImmutablePair<Data, GraphEdge> dataEdgePair = new ImmutablePair<>(data, new GraphEdge());
+ List<ImmutablePair<Data, GraphEdge>> dataEdgeList = new ArrayList<>();
+ dataEdgeList.add(dataEdgePair);
+ return Either.left(dataEdgeList);
+ }
+
+ private Answer<Either<RequirementDefinition, TitanOperationStatus>> createReqDefAnswer() {
+ return new Answer<Either<RequirementDefinition, TitanOperationStatus>>() {
+
+ @Override
+ public Either<RequirementDefinition, TitanOperationStatus> answer(InvocationOnMock invocation)
+ throws Throwable {
+ String reqDataId = (String) invocation.getArguments()[0];
+ return Either.left(FactoryUtils.convertRequirementDataIDToRequirementDefinition(reqDataId));
+ }
+ };
+ }
+
+ private Answer<Either<CapabilityDefinition, TitanOperationStatus>> createCapDefByDataAnswer() {
+ return new Answer<Either<CapabilityDefinition, TitanOperationStatus>>() {
+
+ @Override
+ public Either<CapabilityDefinition, TitanOperationStatus> answer(InvocationOnMock invocation)
+ throws Throwable {
+ CapabilityData capData = (CapabilityData) invocation.getArguments()[0];
+ return Either.left(FactoryUtils.convertCapabilityDataToCapabilityDefinitionAddProperties(capData));
+ }
+ };
+ }
+
+ private ComponentOperation getAnnonimusImpl() {
+ return new ComponentOperation() {
+
+ @Override
+ protected StorageOperationStatus validateCategories(Component currentComponent, Component component,
+ ComponentMetadataData componentData, NodeTypeEnum type) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ protected <T extends Component> StorageOperationStatus updateDerived(Component component,
+ Component currentComponent, ComponentMetadataData updatedResourceData, Class<T> clazz) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ protected <T> Either<T, StorageOperationStatus> updateComponent(T component, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<Integer, StorageOperationStatus> increaseAndGetComponentInstanceCounter(String componentId,
+ boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ protected ComponentMetadataData getMetaDataFromComponent(Component component) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<T, StorageOperationStatus> getLightComponent(String id, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ protected <T> Either<T, StorageOperationStatus> getComponentByNameAndVersion(String name, String version,
+ Map<String, Object> additionalParams, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<T, StorageOperationStatus> getComponent(String id, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // @Override
+ // public <T> Either<T, StorageOperationStatus>
+ // getComponent_tx(String id, boolean inTransaction) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+
+ @Override
+ public Either<List<ArtifactDefinition>, StorageOperationStatus> getAdditionalArtifacts(String resourceId,
+ boolean recursively, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<T, StorageOperationStatus> cloneComponent(T other, String version,
+ boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Component getDefaultComponent() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean isComponentExist(String componentId) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public Either<Component, StorageOperationStatus> getMetadataComponent(String id, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ Component convertComponentMetadataDataToComponent(ComponentMetadataData componentMetadataData) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ TitanOperationStatus setComponentCategoriesFromGraph(Component component) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<Boolean, StorageOperationStatus> validateComponentNameExists(String componentName) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<Component, StorageOperationStatus> markComponentToDelete(Component componentToDelete,
+ boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<Component, StorageOperationStatus> deleteComponent(String id, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<Boolean, StorageOperationStatus> isComponentInUse(String componentId) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Either<List<String>, StorageOperationStatus> getAllComponentsMarkedForDeletion() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<T, StorageOperationStatus> cloneComponent(T other, String version,
+ LifecycleStateEnum targetLifecycle, boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<T, StorageOperationStatus> getComponent(String id,
+ ComponentParametersView componentParametersView, boolean inTrasnaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> Either<List<T>, StorageOperationStatus> getFilteredComponents(Map<FilterKeyEnum, String> filters,
+ boolean inTransaction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ protected <T> Either<T, StorageOperationStatus> updateComponentFilterResult(T component,
+ boolean inTransaction, ComponentParametersView filterParametersView) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ };
+ }
+
+}
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
new file mode 100644
index 0000000000..a529074db6
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ElementOperationTest.java
@@ -0,0 +1,109 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+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.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactType;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.operations.impl.ElementOperation;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ElementOperationTest extends ModelTestBase {
+
+ @javax.annotation.Resource(name = "element-operation")
+ private ElementOperation elementOperation;
+
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ private static String CATEGORY = "category";
+ private static String SUBCATEGORY = "subcategory";
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ // ExternalConfiguration.setAppName("catalog-model");
+ // String appConfigDir = "src/test/resources/config/catalog-model";
+ // ConfigurationSource configurationSource = new
+ // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ // appConfigDir);
+
+ ModelTestBase.init();
+
+ }
+
+ @Test
+ public void testGetArtifactsTypes() {
+
+ List<String> artifactTypesCfg = new ArrayList<String>();
+ artifactTypesCfg.add("type1");
+ artifactTypesCfg.add("type2");
+ artifactTypesCfg.add("type3");
+ artifactTypesCfg.add("type4");
+ configurationManager.getConfiguration().setArtifactTypes(artifactTypesCfg);
+ Either<List<ArtifactType>, ActionStatus> allArtifactTypes = elementOperation.getAllArtifactTypes();
+ assertTrue(allArtifactTypes.isLeft());
+ assertEquals(artifactTypesCfg.size(), allArtifactTypes.left().value().size());
+
+ artifactTypesCfg.remove(0);
+ allArtifactTypes = elementOperation.getAllArtifactTypes();
+ assertTrue(allArtifactTypes.isLeft());
+ assertEquals(artifactTypesCfg.size(), allArtifactTypes.left().value().size());
+
+ artifactTypesCfg.add("type5");
+ }
+
+ // @Test
+ public void testGetResourceAndServiceCategoty() {
+ String id = OperationTestsUtil.deleteAndCreateResourceCategory(CATEGORY, SUBCATEGORY, titanDao);
+
+ Either<CategoryDefinition, ActionStatus> res = elementOperation.getCategory(NodeTypeEnum.ResourceNewCategory,
+ id);
+ assertTrue(res.isLeft());
+ CategoryDefinition categoryDefinition = (CategoryDefinition) res.left().value();
+ assertEquals(CATEGORY, categoryDefinition.getName());
+ assertEquals(SUBCATEGORY, categoryDefinition.getSubcategories().get(0).getName());
+
+ id = OperationTestsUtil.deleteAndCreateServiceCategory(CATEGORY, titanDao);
+
+ res = elementOperation.getCategory(NodeTypeEnum.ServiceNewCategory, id);
+ assertTrue(res.isLeft());
+ categoryDefinition = (CategoryDefinition) res.left().value();
+ assertEquals(CATEGORY, categoryDefinition.getName());
+ }
+}
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
new file mode 100644
index 0000000000..6765557bab
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java
@@ -0,0 +1,289 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.anyMap;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+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.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;
+import org.openecomp.sdc.be.model.heat.HeatParameterType;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation;
+import org.openecomp.sdc.be.resources.data.HeatParameterData;
+import org.openecomp.sdc.be.resources.data.HeatParameterValueData;
+
+import fj.data.Either;
+
+public class HeatParametersOperationTest extends ModelTestBase {
+
+ HeatParametersOperation heatParametersOperation = new HeatParametersOperation();
+
+ TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
+
+ @Before
+ public void setup() {
+ heatParametersOperation.setTitanGenericDao(titanGenericDao);
+
+ }
+
+ @Test
+ public void addPropertyToResourceTest() {
+
+ String propName = "myProp";
+ HeatParameterDefinition property = buildHeatPropertyDefinition();
+
+ HeatParameterData propertyData = new HeatParameterData(property);
+
+ Either<HeatParameterData, TitanOperationStatus> either = Either.left(propertyData);
+
+ GraphRelation graphRelation = new GraphRelation();
+ Either<GraphRelation, TitanOperationStatus> relationResult = Either.left(graphRelation);
+
+ when(titanGenericDao.createNode((HeatParameterData) anyObject(), eq(HeatParameterData.class)))
+ .thenReturn(either);
+ when(titanGenericDao.createRelation((GraphNode) anyObject(), (GraphNode) anyObject(),
+ eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult);
+
+ Either<HeatParameterData, TitanOperationStatus> result = heatParametersOperation.addPropertyToGraph(propName,
+ property, "resourceId.artifactId", NodeTypeEnum.ArtifactRef);
+
+ assertTrue(result.isLeft());
+
+ }
+
+ @Test
+ public void addPropertyListToResourceTest() {
+
+ HeatParameterDefinition property = buildHeatPropertyDefinition();
+ HeatParameterDefinition property2 = buildHeatPropertyDefinition();
+ property2.setName("p2");
+
+ List<HeatParameterDefinition> parameters = new ArrayList<HeatParameterDefinition>();
+ parameters.add(property);
+ parameters.add(property2);
+
+ HeatParameterData propertyData = new HeatParameterData(property);
+
+ Either<HeatParameterData, TitanOperationStatus> either = Either.left(propertyData);
+
+ GraphRelation graphRelation = new GraphRelation();
+ Either<GraphRelation, TitanOperationStatus> relationResult = Either.left(graphRelation);
+
+ when(titanGenericDao.createNode((HeatParameterData) anyObject(), eq(HeatParameterData.class)))
+ .thenReturn(either);
+ when(titanGenericDao.createRelation((GraphNode) anyObject(), (GraphNode) anyObject(),
+ eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult);
+
+ StorageOperationStatus result = heatParametersOperation.addPropertiesToGraph(parameters,
+ "resourceId.artifactId", NodeTypeEnum.ArtifactRef);
+
+ assertEquals(StorageOperationStatus.OK, result);
+
+ }
+
+ @Test
+ public void testStringValues() {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.STRING, "50aaa"));
+ }
+
+ @Test
+ public void testNumberValues() {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.NUMBER, "50"));
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.NUMBER, "50.5"));
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.NUMBER, "0x11"));
+
+ assertFalse(heatParametersOperation.isValidValue(HeatParameterType.NUMBER, "aaa"));
+ assertFalse(heatParametersOperation.isValidValue(HeatParameterType.NUMBER, "?>!"));
+ }
+
+ @Test
+ public void testJsonValues() {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.JSON, "{ \"member\" : \"50\"}"));
+ HeatParameterDefinition propertyDefinition = buildHeatBooleanPropertyDefinition(
+ HeatParameterType.JSON.getType(), "{ \"member\" : \"50\"}");
+ StorageOperationStatus operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals(HeatParameterType.JSON.getType(), propertyDefinition.getType());
+
+ }
+
+ @Test
+ public void testListValues() {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.COMMA_DELIMITED_LIST, "one, two"));
+ HeatParameterDefinition propertyDefinition = buildHeatBooleanPropertyDefinition(
+ HeatParameterType.COMMA_DELIMITED_LIST.getType(), "one, two");
+ StorageOperationStatus operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals(HeatParameterType.COMMA_DELIMITED_LIST.getType(), propertyDefinition.getType());
+ assertEquals("one, two", propertyDefinition.getDefaultValue());
+ }
+
+ @Test
+ public void testBooleanValues() {
+
+ String[] trueArray = { "true", "t", "1", "on", "y", "yes" };
+ String[] falseArray = { "false", "f", "0", "off", "n", "no" };
+
+ for (int i = 0; i < trueArray.length; i++) {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, trueArray[i]));
+ HeatParameterDefinition propertyDefinition = buildHeatBooleanPropertyDefinition(
+ HeatParameterType.BOOLEAN.getType(), trueArray[i]);
+ StorageOperationStatus operationStatus = heatParametersOperation
+ .validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("true", propertyDefinition.getDefaultValue());
+
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, trueArray[i]));
+ propertyDefinition = buildHeatBooleanPropertyDefinition(HeatParameterType.BOOLEAN.getType(),
+ trueArray[i].toUpperCase());
+ operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("true", propertyDefinition.getDefaultValue());
+
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, trueArray[i]));
+ propertyDefinition = buildHeatBooleanPropertyDefinition(HeatParameterType.BOOLEAN.getType(),
+ trueArray[i].toLowerCase());
+ operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("true", propertyDefinition.getDefaultValue());
+ }
+
+ for (int i = 0; i < falseArray.length; i++) {
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, falseArray[i]));
+ HeatParameterDefinition propertyDefinition = buildHeatBooleanPropertyDefinition(
+ HeatParameterType.BOOLEAN.getType(), falseArray[i]);
+ StorageOperationStatus operationStatus = heatParametersOperation
+ .validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("false", propertyDefinition.getDefaultValue());
+
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, falseArray[i]));
+ propertyDefinition = buildHeatBooleanPropertyDefinition(HeatParameterType.BOOLEAN.getType(),
+ falseArray[i].toUpperCase());
+ operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("false", propertyDefinition.getDefaultValue());
+
+ assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, falseArray[i]));
+ propertyDefinition = buildHeatBooleanPropertyDefinition(HeatParameterType.BOOLEAN.getType(),
+ falseArray[i].toLowerCase());
+ operationStatus = heatParametersOperation.validateAndUpdateProperty(propertyDefinition);
+ assertEquals(StorageOperationStatus.OK, operationStatus);
+ assertEquals("false", propertyDefinition.getDefaultValue());
+ }
+
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "true"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "t"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "1"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "on"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "y"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "yes"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "false"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "f"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "0"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "off"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "n"));
+ // assertTrue(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN,
+ // "no"));
+
+ assertFalse(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, "blabla"));
+ assertFalse(heatParametersOperation.isValidValue(HeatParameterType.BOOLEAN, "2"));
+ }
+
+ private HeatParameterDefinition buildHeatPropertyDefinition() {
+ HeatParameterDefinition parameter = new HeatParameterDefinition();
+
+ parameter.setName("p1");
+ parameter.setType("string");
+ parameter.setDefaultValue("def");
+ parameter.setCurrentValue("current");
+ parameter.setDescription("description");
+
+ return parameter;
+ }
+
+ private HeatParameterDefinition buildHeatBooleanPropertyDefinition(String type, String boolValue) {
+ HeatParameterDefinition parameter = new HeatParameterDefinition();
+
+ parameter.setName("parameter1");
+ parameter.setType(type);
+ parameter.setDefaultValue(boolValue);
+ parameter.setDescription("description");
+
+ return parameter;
+ }
+
+ @Test
+ public void addPropertyToResourceInstanceTest() {
+
+ HeatParameterDefinition property = buildHeatPropertyDefinition();
+
+ HeatParameterValueData propertyData = new HeatParameterValueData();
+ propertyData.setUniqueId("bla");
+ propertyData.setValue("value1");
+
+ Either<HeatParameterValueData, TitanOperationStatus> either = Either.left(propertyData);
+
+ GraphRelation graphRelation = new GraphRelation();
+ Either<GraphRelation, TitanOperationStatus> relationResult = Either.left(graphRelation);
+
+ when(titanGenericDao.createNode((HeatParameterValueData) anyObject(), eq(HeatParameterValueData.class)))
+ .thenReturn(either);
+ when(titanGenericDao.createRelation((GraphNode) anyObject(), (GraphNode) anyObject(),
+ eq(GraphEdgeLabels.PARAMETER_VALUE), anyMap())).thenReturn(relationResult);
+ when(titanGenericDao.createRelation((GraphNode) anyObject(), (GraphNode) anyObject(),
+ eq(GraphEdgeLabels.PARAMETER_IMPL), anyMap())).thenReturn(relationResult);
+
+ Either<HeatParameterValueData, TitanOperationStatus> 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/InterfaceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceOperationTest.java
new file mode 100644
index 0000000000..e1eb7db070
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceOperationTest.java
@@ -0,0 +1,272 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.HashMap;
+import java.util.Map;
+
+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.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+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.Resource;
+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.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class InterfaceOperationTest {
+ private static Logger log = LoggerFactory.getLogger(InterfaceOperationTest.class.getName());
+ private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+
+ private static String USER_ID = "muserId";
+ private static String CATEGORY_NAME = "category/mycategory";
+ // InterfaceLifecycleOperation interfaceOperation = new
+ // InterfaceLifecycleOperation();
+
+ // TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "interface-operation")
+ private InterfaceLifecycleOperation interfaceOperation;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ // @Resource(name = "artifact-operation")
+ // private ArtifactOperation artifactOperation;
+
+ @Before
+ public void createUserAndCategory() {
+ deleteAndCreateCategory(CATEGORY_NAME);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
+ }
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ // ExternalConfiguration.setAppName("catalog-model");
+ // String appConfigDir = "src/test/resources/config/catalog-model";
+ // ConfigurationSource configurationSource = new
+ // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ // appConfigDir);
+
+ ModelTestBase.init();
+
+ }
+
+ @Test
+ public void testDummy() {
+
+ assertTrue(interfaceOperation != null);
+
+ }
+
+ @Test
+ public void addInterfaceToResourceTest() {
+
+ String capabilityTypeName = "mycapability1";
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute1";
+ String rootName = "Root100";
+ String softwareCompName = "tosca.nodes.SoftwareComponent";
+ String computeNodeName = "tosca.nodes.Compute";
+ String myResourceVersion = "300.0";
+ String reqRelationship = "myrelationship";
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "100.0", null,
+ true, true);
+
+ String interfaceName = "standard";
+ InterfaceDefinition interfaceDefinition = buildInterfaceDefinition();
+
+ Operation op = buildOperationDefinition();
+ Map<String, Operation> operations = new HashMap<String, Operation>();
+ operations.put("Create", op);
+ interfaceDefinition.setOperations(operations);
+
+ Either<InterfaceDefinition, StorageOperationStatus> result = interfaceOperation
+ .addInterfaceToResource(interfaceDefinition, rootResource.getUniqueId(), "standard");
+
+ assertTrue(result.isLeft());
+ log.debug("{}", result.left().value());
+
+ Either<Resource, StorageOperationStatus> getResourceRes = resourceOperation
+ .getResource(rootResource.getUniqueId());
+ assertTrue(getResourceRes.isLeft());
+ Resource resourceWithInterface = getResourceRes.left().value();
+ Map<String, InterfaceDefinition> interfaces = resourceWithInterface.getInterfaces();
+ assertNotNull(interfaces);
+ assertFalse(interfaces.isEmpty());
+ InterfaceDefinition interfaceDefinition2 = interfaces.get(interfaceName);
+ assertNotNull(interfaceDefinition2.getOperations());
+ assertFalse(interfaceDefinition2.getOperations().isEmpty());
+
+ }
+
+ @Test
+ public void updateInterfaceToResourceTest() {
+
+ String reqName = "host";
+ String rootName = "Root200";
+ String softwareCompName = "tosca.nodes.SoftwareComponent";
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "200.0", null,
+ true, true);
+
+ String interfaceName = "standard";
+ InterfaceDefinition interfaceDefinition = buildInterfaceDefinition();
+
+ Operation op = buildOperationDefinition();
+ Map<String, Operation> operations = new HashMap<String, Operation>();
+ operations.put("create", op);
+ interfaceDefinition.setOperations(operations);
+
+ Either<InterfaceDefinition, StorageOperationStatus> result = interfaceOperation
+ .addInterfaceToResource(interfaceDefinition, rootResource.getUniqueId(), "standard");
+
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId());
+
+ assertTrue(fetchRootResource.isLeft());
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "400.0", rootResource.getName(), true, true);
+
+ assertTrue(result.isLeft());
+ log.debug("{}", result.left().value());
+
+ addImplementationToOperation(op);
+ // String resourceId, String interfaceName, String
+ // operationName,Operation interf
+
+ Either<Operation, StorageOperationStatus> opResult = interfaceOperation
+ .updateInterfaceOperation(softwareComponent.getUniqueId(), "standard", "create", op);
+ // PrintGraph pg = new PrintGraph();
+ // System.out.println(pg.buildGraphForWebgraphWiz(titanDao.getGraph().left().value()));
+ assertTrue(opResult.isLeft());
+ log.debug("{}", opResult.left().value());
+
+ Either<Resource, StorageOperationStatus> getResourceRes = resourceOperation
+ .getResource(softwareComponent.getUniqueId());
+ assertTrue(getResourceRes.isLeft());
+ Resource resourceWithInterface = getResourceRes.left().value();
+ Map<String, InterfaceDefinition> interfaces = resourceWithInterface.getInterfaces();
+ assertNotNull(interfaces);
+ assertFalse(interfaces.isEmpty());
+ InterfaceDefinition interfaceDefinition2 = interfaces.get(interfaceName);
+ assertNotNull(interfaceDefinition2.getOperations());
+ assertFalse(interfaceDefinition2.getOperations().isEmpty());
+ Operation operation = interfaceDefinition2.getOperations().get("create");
+ assertNotNull(operation);
+ assertNotNull(operation.getImplementation());
+ }
+
+ private void addImplementationToOperation(Operation op) {
+ ArtifactDataDefinition artifactDataDef = new ArtifactDataDefinition();
+ artifactDataDef.setArtifactChecksum("YTg2Mjg4MWJhNmI5NzBiNzdDFkMWI=");
+ artifactDataDef.setArtifactName("create_myRoot.sh");
+ artifactDataDef.setArtifactLabel("create_myRoot");
+ artifactDataDef.setArtifactType("SHELL");
+ artifactDataDef.setDescription("good description");
+ artifactDataDef.setEsId("esId");
+ artifactDataDef.setUniqueId(op.getUniqueId() + "." + artifactDataDef.getArtifactLabel());
+ ArtifactDefinition artifactDef = new ArtifactDefinition(artifactDataDef, "UEsDBAoAAAAIAAeLb0bDQz");
+ op.setImplementation(artifactDef);
+ }
+
+ private InterfaceDefinition buildInterfaceDefinition() {
+ InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.standard");
+ interfaceDefinition.setCreationDate(new Long(101232));
+
+ return interfaceDefinition;
+ }
+
+ private Operation buildOperationDefinition() {
+ Operation op = new Operation();
+ op.setCreationDate(new Long(101232));
+ op.setDescription("asda");
+
+ return op;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/LifecycleOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/LifecycleOperationTest.java
new file mode 100644
index 0000000000..2b090f6f9f
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/LifecycleOperationTest.java
@@ -0,0 +1,1991 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.After;
+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.graph.datatype.GraphRelation;
+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.components.ServiceMetadataDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+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.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.operations.impl.util.ResourceCreationUtils;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.be.resources.data.CapabilityData;
+import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
+import org.openecomp.sdc.be.resources.data.InterfaceData;
+import org.openecomp.sdc.be.resources.data.OperationData;
+import org.openecomp.sdc.be.resources.data.RequirementData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.thinkaurelius.titan.core.TitanGraph;
+//import com.tinkerpop.blueprints.Vertex;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class LifecycleOperationTest extends ModelTestBase {
+ private static Logger log = LoggerFactory.getLogger(LifecycleOperationTest.class.getName());
+ private static final String CAPABILITY_HOSTED_ON = "HostedOn";
+
+ private static final String INTERFACE_OPERATION_CREATE = "create";
+
+ private static final String INTERFACE_NAME = "standard";
+
+ private static final String CATEGORY_NAME = "category/mycategory";
+
+ private static final String SERVICE_NAME = "myService";
+
+ private static final String REQUIREMENT_NAME = "requirementName";
+
+ private static final String CAPABILITY_NAME = "capName";
+
+ private static final String USER_ID = "muserId";
+
+ @javax.annotation.Resource
+ private TitanGenericDao titanGenericDao;
+
+ @javax.annotation.Resource
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource
+ private ServiceOperation serviceOperation;
+
+ @javax.annotation.Resource
+ private LifecycleOperation lifecycleOperation;
+
+ @javax.annotation.Resource
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @javax.annotation.Resource
+ private ArtifactOperation artifactOperation;
+
+ @javax.annotation.Resource
+ private InterfaceLifecycleOperation interfaceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation resourceInstanceOperation;
+
+ @javax.annotation.Resource(name = "requirement-operation")
+ private RequirementOperation requirementOperation;
+
+ User checkoutUser;
+ User checkinUser;
+ User rfcUser;
+ User testerUser;
+ User adminUser;
+
+ @Rule
+ public TestName name = new TestName();
+
+ @BeforeClass
+ public static void initLifecycleOperation() {
+ ModelTestBase.init();
+ // new ConfigurationSource() {
+ //
+ // @Override
+ // public <T> T getAndWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+ //
+ // @Override
+ // public <T> void addWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ //
+ // }
+ // });
+ //
+
+ }
+
+ @Before
+ public void setupBefore() {
+ clearGraph();
+ UserData modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "co",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
+ checkoutUser = convertUserDataToUser(modifierData);
+
+ modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "ci",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
+ checkinUser = convertUserDataToUser(modifierData);
+
+ modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "rfc",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
+ rfcUser = convertUserDataToUser(modifierData);
+
+ modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "tester",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "TESTER");
+ testerUser = convertUserDataToUser(modifierData);
+
+ modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "admin",
+ ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
+ adminUser = convertUserDataToUser(modifierData);
+
+ modifierData = deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, "ADMIN");
+ adminUser = convertUserDataToUser(modifierData);
+
+ String[] category = CATEGORY_NAME.split("/");
+ OperationTestsUtil.deleteAndCreateServiceCategory(CATEGORY_NAME, titanGenericDao);
+ OperationTestsUtil.deleteAndCreateResourceCategory(category[0], category[1], titanGenericDao);
+
+ }
+
+ @After
+ public void teardown() {
+ clearGraph();
+ }
+
+ private void clearGraph() {
+ Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
+ TitanGraph graph = graphResult.left().value();
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ TitanVertex vertex = iterator.next();
+ // graph.removeVertex(vertex);
+ vertex.remove();
+ }
+
+ }
+ titanGenericDao.commit();
+ }
+
+ @Test
+ public void getOwnerTest() {
+
+ Resource resultResource = createTestResource(checkoutUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(resultResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals("check modifier", checkoutUser.getUserId(), resourceOwner.getUserId());
+
+ }
+
+ /*********************** CHECKOUT ***************************************************************/
+
+ @Test
+ public void checkoutCertifiedTest() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null);
+ String origUniqueId = resultResource.getUniqueId();
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation.getResource(origUniqueId);
+ Resource origResource = origResourceResult.left().value();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkout
+ Either<Resource, StorageOperationStatus> checkoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse.isLeft());
+ Resource checkoutResource = checkoutResponse.left().value();
+
+ assertEquals(checkoutResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ assertEquals(checkoutResource.getVersion(), "1.1");
+ assertEquals(checkoutResource.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(checkoutResource.getLastUpdaterUserId(), checkoutUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkoutResource.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkoutUser));
+
+ // assert original resource not deleted
+ Either<Resource, StorageOperationStatus> getOrigResource = resourceOperation.getResource(origUniqueId);
+ assertEquals("check resource created", true, getOrigResource.isLeft());
+ // assertEquals("assert original resource not changed", origResource,
+ // getOrigResource.left().value());
+ }
+
+ @Test
+ public void checkoutDefaultTest() {
+
+ Resource resultResource = createTestResource(checkinUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkout
+ Either<Resource, StorageOperationStatus> checkoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse.isLeft());
+ Resource checkoutResource = checkoutResponse.left().value();
+
+ assertEquals(checkoutResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ assertEquals(checkoutResource.getVersion(), "0.2");
+ assertEquals(checkoutResource.getCreatorUserId(), checkinUser.getUserId());
+ assertEquals(checkoutResource.getLastUpdaterUserId(), checkoutUser.getUserId());
+ assertEquals(checkoutResource.isHighestVersion(), true);
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkoutResource.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkoutUser));
+
+ // assert original resource not deleted
+ Either<Resource, StorageOperationStatus> getOrigResource = resourceOperation.getResource(origUniqueId);
+ assertEquals("check resource created", true, getOrigResource.isLeft());
+ // assertEquals("assert original resource not changed", origResource,
+ // getOrigResource.left().value());
+ assertEquals("assert original resource not highest version", false,
+ getOrigResource.left().value().isHighestVersion());
+ }
+
+ @Test
+ public void checkoutFullResourceTest() {
+
+ Resource origResource = createFullTestResource(checkinUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ String origUniqueId = origResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkout
+ Either<Resource, StorageOperationStatus> checkoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, origResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse.isLeft());
+ Resource checkoutResource = checkoutResponse.left().value();
+
+ assertEquals(checkoutResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ assertEquals(checkoutResource.getVersion(), "0.2");
+ assertEquals(checkoutResource.getCreatorUserId(), checkinUser.getUserId());
+ assertEquals(checkoutResource.getLastUpdaterUserId(), checkoutUser.getUserId());
+ assertEquals(checkoutResource.isHighestVersion(), true);
+
+ assertNotNull(checkoutResource.getArtifacts());
+ assertFalse(checkoutResource.getArtifacts().isEmpty());
+ assertNotNull(checkoutResource.getInterfaces());
+ assertFalse(checkoutResource.getInterfaces().isEmpty());
+ Map<String, InterfaceDefinition> interfaces = checkoutResource.getInterfaces();
+ assertTrue(interfaces.containsKey(INTERFACE_NAME));
+ InterfaceDefinition interfaceDef = interfaces.get(INTERFACE_NAME);
+ Map<String, Operation> operations = interfaceDef.getOperations();
+ assertNotNull(operations);
+ assertFalse(operations.isEmpty());
+ assertTrue(operations.containsKey(INTERFACE_OPERATION_CREATE));
+ Operation op = operations.get(INTERFACE_OPERATION_CREATE);
+ assertNotNull(op.getImplementation());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkoutResource.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkoutUser));
+
+ // assert original resource not deleted
+ Either<Resource, StorageOperationStatus> getOrigResource = resourceOperation.getResource(origUniqueId);
+ assertEquals("check resource created", true, getOrigResource.isLeft());
+ // assertEquals("assert original resource not changed", origResource,
+ // getOrigResource.left().value());
+ assertEquals("assert original resource not highest version", false,
+ getOrigResource.left().value().isHighestVersion());
+ }
+
+ @Test
+ public void getResourceOwnerResourceNotExistTest() {
+
+ // create resource metadata
+ Resource resource = buildResourceMetadata(adminUser.getUserId(), CATEGORY_NAME);
+ resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
+ resource.setUniqueId("my-resource.0.1");
+
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation.getResource("my-resource.0.1");
+ assertEquals("assert resource not exist", true, origResourceResult.isRight());
+
+ // get resource owner
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner("my-resource.0.1",
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("assert no owner", true, getOwnerResponse.isRight());
+ StorageOperationStatus status = getOwnerResponse.right().value();
+
+ assertEquals(StorageOperationStatus.INVALID_ID, status);
+
+ }
+
+ @Test
+ public void checkoutResourceTwice() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null);
+ String origUniqueId = resultResource.getUniqueId();
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation.getResource(origUniqueId);
+ Resource origResource = origResourceResult.left().value();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // first checkout
+ Either<Resource, StorageOperationStatus> checkoutResponse1 = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse1.isLeft());
+
+ // second checkout
+ Either<Resource, StorageOperationStatus> checkoutResponse2 = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, origResource, checkoutUser, resourceOwner, false);
+ assertEquals("check checkout failed", true, checkoutResponse2.isRight());
+ assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, checkoutResponse2.right().value());
+
+ }
+
+ /******** SERVICE */
+ @Test
+ public void checkoutServiceDefaultTest() {
+
+ Service resultResource = createTestService(checkinUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkout
+ Either<? extends Component, StorageOperationStatus> checkoutResponse = lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Service, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse.isLeft());
+ Component checkoutResource = checkoutResponse.left().value();
+
+ assertEquals(checkoutResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ assertEquals(checkoutResource.getVersion(), "0.2");
+ assertEquals(checkoutResource.getCreatorUserId(), checkinUser.getUserId());
+ assertEquals(checkoutResource.getLastUpdaterUserId(), checkoutUser.getUserId());
+ assertEquals(checkoutResource.isHighestVersion(), true);
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkoutResource.getUniqueId(), NodeTypeEnum.Service, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkoutUser));
+
+ // assert original resource not deleted
+ Either<Service, StorageOperationStatus> getOrigResource = serviceOperation.getService(origUniqueId);
+ assertEquals("check resource created", true, getOrigResource.isLeft());
+ // assertEquals("assert original resource not changed", origResource,
+ // getOrigResource.left().value());
+ assertEquals("assert original resource not highest version", false,
+ getOrigResource.left().value().isHighestVersion());
+ }
+
+ @Test
+ public void checkoutFullServiceTest() {
+
+ Service origService = createTestService(checkinUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ String origUniqueId = origService.getUniqueId();
+
+ // add artifacts
+ addArtifactToService(checkinUser.getUserId(), origService.getUniqueId(), "install_apache");
+ addArtifactToService(checkinUser.getUserId(), origService.getUniqueId(), "start_apache");
+
+ // add resource instances
+ ResourceInstanceOperationTest riTest = new ResourceInstanceOperationTest();
+ riTest.setOperations(titanGenericDao, capabilityTypeOperation, requirementOperation, capabilityOperation,
+ resourceOperation, propertyOperation, resourceInstanceOperation);
+ riTest.addResourceInstancesAndRelation(origService.getUniqueId());
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ Either<Service, StorageOperationStatus> serviceBeforeCheckout = serviceOperation.getService(origUniqueId, true);
+ assertTrue(serviceBeforeCheckout.isLeft());
+ origService = serviceBeforeCheckout.left().value();
+
+ // checkout
+ Either<? extends Component, StorageOperationStatus> checkoutResponse = lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Service, origService, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse.isLeft());
+ Service checkoutResource = (Service) checkoutResponse.left().value();
+
+ assertEquals(checkoutResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ assertEquals(checkoutResource.getVersion(), "0.2");
+ assertEquals(checkoutResource.getCreatorUserId(), checkinUser.getUserId());
+ assertEquals(checkoutResource.getLastUpdaterUserId(), checkoutUser.getUserId());
+ assertEquals(checkoutResource.isHighestVersion(), true);
+
+ assertNotNull(checkoutResource.getArtifacts());
+ assertFalse(checkoutResource.getArtifacts().isEmpty());
+ assertNotNull(checkoutResource.getComponentInstances());
+ assertFalse(checkoutResource.getComponentInstances().isEmpty());
+ assertNotNull(checkoutResource.getComponentInstancesRelations());
+ assertFalse(checkoutResource.getComponentInstancesRelations().isEmpty());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkoutResource.getUniqueId(), NodeTypeEnum.Service, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkoutUser));
+
+ // assert original resource not deleted
+ Either<Service, StorageOperationStatus> getOrigResource = serviceOperation.getService(origUniqueId);
+ assertEquals("check service created", true, getOrigResource.isLeft());
+ // assertEquals("assert original resource not changed", origResource,
+ // getOrigResource.left().value());
+ assertEquals("assert original service not highest version", false,
+ getOrigResource.left().value().isHighestVersion());
+ }
+
+ @Test
+ public void checkoutServiceTwice() {
+
+ Service resultResource = createTestService(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null);
+ String origUniqueId = resultResource.getUniqueId();
+ Either<Service, StorageOperationStatus> origResourceResult = serviceOperation.getService(origUniqueId);
+ Service origResource = origResourceResult.left().value();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // first checkout
+ Either<? extends Component, StorageOperationStatus> checkoutResponse1 = lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Service, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkoutResponse1.isLeft());
+
+ // second checkout
+ Either<? extends Component, StorageOperationStatus> checkoutResponse2 = lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Service, origResource, checkoutUser, resourceOwner, false);
+ assertEquals("check checkout failed", true, checkoutResponse2.isRight());
+ assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, checkoutResponse2.right().value());
+
+ }
+
+ /**************************** CHECKIN ********************************************************************/
+
+ @Test
+ public void checkinDefaultTest() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<Resource, StorageOperationStatus> checkinResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkinComponent(NodeTypeEnum.Resource, resultResource, checkinUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkinResponse.isLeft());
+ Resource checkinResource = checkinResponse.left().value();
+
+ assertEquals(checkinResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ assertEquals(checkinResource.getVersion(), "0.1");
+ assertEquals(checkinResource.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(checkinResource.getLastUpdaterUserId(), checkinUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkinResource.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkinUser));
+
+ }
+
+ @Test
+ public void checkinFromRfcTest() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<Resource, StorageOperationStatus> checkinResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkinComponent(NodeTypeEnum.Resource, resultResource, checkinUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, checkinResponse.isLeft());
+
+ // rfc
+ Either<Resource, StorageOperationStatus> rfcResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, checkinResponse.left().value(), rfcUser,
+ checkinUser, false);
+ assertEquals("check resource object is returned", true, checkinResponse.isLeft());
+
+ // checkin (cancel rfc)
+ checkinResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkinComponent(NodeTypeEnum.Resource, rfcResponse.left().value(), checkinUser, rfcUser, false);
+ assertEquals("check resource object is returned", true, checkinResponse.isLeft());
+ resultResource = checkinResponse.left().value();
+
+ assertEquals(resultResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ assertEquals(resultResource.getVersion(), "0.1");
+ assertEquals(resultResource.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(resultResource.getLastUpdaterUserId(), checkinUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(resultResource.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkinUser));
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(resultResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ /*** SERVICE */
+ @Test
+ public void checkinServiceDefaultTest() {
+
+ Service resultService = createTestService(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultService.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<? extends Component, StorageOperationStatus> checkinResponse = lifecycleOperation
+ .checkinComponent(NodeTypeEnum.Service, resultService, checkinUser, resourceOwner, false);
+ assertEquals("check service object is returned", true, checkinResponse.isLeft());
+ Service checkinResource = (Service) checkinResponse.left().value();
+
+ assertEquals(checkinResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ assertEquals(checkinResource.getVersion(), "0.1");
+ assertEquals(checkinResource.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(checkinResource.getLastUpdaterUserId(), checkinUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(checkinResource.getUniqueId(), NodeTypeEnum.Service, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkinUser));
+
+ }
+
+ @Test
+ public void checkinServiceFromRfcTest() {
+
+ Service resultResource = createTestService(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<? extends Component, StorageOperationStatus> checkinResponse = lifecycleOperation
+ .checkinComponent(NodeTypeEnum.Service, resultResource, checkinUser, resourceOwner, false);
+ assertEquals("check service object is returned", true, checkinResponse.isLeft());
+
+ // rfc
+ Either<? extends Component, StorageOperationStatus> rfcResponse = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, checkinResponse.left().value(), rfcUser,
+ checkinUser, false);
+ assertEquals("check service object is returned", true, checkinResponse.isLeft());
+
+ // checkin (cancel rfc)
+ checkinResponse = lifecycleOperation.checkinComponent(NodeTypeEnum.Service, rfcResponse.left().value(),
+ checkinUser, rfcUser, false);
+ assertEquals("check resource object is returned", true, checkinResponse.isLeft());
+ resultResource = (Service) checkinResponse.left().value();
+
+ assertEquals(resultResource.getLifecycleState(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ assertEquals(resultResource.getVersion(), "0.1");
+ assertEquals(resultResource.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(resultResource.getLastUpdaterUserId(), checkinUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(resultResource.getUniqueId(), NodeTypeEnum.Service, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(checkinUser));
+
+ // assert relations
+ ServiceMetadataDataDefinition metadata = new ServiceMetadataDataDefinition();
+ metadata.setUniqueId(resultResource.getUniqueId());
+ ServiceMetadataData resourceData = new ServiceMetadataData(metadata);
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ /****************************
+ * UNDO CHECKOUT
+ ********************************************************************/
+
+ @Test
+ public void undoCheckoutNewResourceTest() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ //
+
+ // undo checkout
+ Either<Resource, StorageOperationStatus> undoCheckoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Resource, resultResource, adminUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation.getResource(origUniqueId);
+ assertTrue(origResourceResult.isRight());
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */
+ }
+
+ @Test
+ public void undoCheckoutNewFullResourceTest() {
+
+ Resource resultResource = createFullTestResource(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // undo checkout
+ Either<Resource, StorageOperationStatus> undoCheckoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Resource, resultResource, adminUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation.getResource(origUniqueId);
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */ assertTrue(origResourceResult.isRight());
+
+ String interfaceId = origUniqueId + "." + INTERFACE_NAME;
+ Either<InterfaceData, TitanOperationStatus> node = titanGenericDao
+ .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class);
+ assertTrue(node.isRight());
+
+ String operationId = interfaceId + "." + INTERFACE_OPERATION_CREATE;
+ Either<OperationData, TitanOperationStatus> op = titanGenericDao.getNode(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), operationId, OperationData.class);
+ assertTrue(op.isRight());
+
+ String capabilityId = "capability." + origUniqueId + "." + CAPABILITY_NAME;
+ Either<CapabilityData, TitanOperationStatus> capability = titanGenericDao
+ .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Capability), capabilityId, CapabilityData.class);
+ assertTrue(capability.isRight());
+
+ String requirementId = origUniqueId + "." + REQUIREMENT_NAME;
+ Either<RequirementData, TitanOperationStatus> req = titanGenericDao.getNode(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Requirement), requirementId, RequirementData.class);
+ assertTrue(req.isRight());
+
+ }
+
+ @Test
+ public void undoCheckoutExistingResourceTest() {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(resultResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ String prevResourceId = resultResource.getUniqueId();
+ Either<Resource, StorageOperationStatus> result2 = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource created", true, result2.isLeft());
+ Resource resultResource2 = result2.left().value();
+
+ // get resource owner
+ getOwnerResponse = lifecycleOperation.getComponentOwner(resultResource2.getUniqueId(), NodeTypeEnum.Resource,
+ false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ resourceOwner = getOwnerResponse.left().value();
+ assertEquals(resourceOwner, checkoutUser);
+
+ // undo checkout
+ Either<Resource, StorageOperationStatus> undoCheckoutResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Resource, resultResource2, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ // get previous resource
+ Either<Resource, StorageOperationStatus> resourceAfterUndo = resourceOperation.getResource(prevResourceId);
+ assertTrue(resourceAfterUndo.isLeft());
+ Resource actualResource = resourceAfterUndo.left().value();
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(adminUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(adminUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals("0.1", actualResource.getVersion());
+ assertEquals(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, actualResource.getLifecycleState());
+
+ Either<Resource, StorageOperationStatus> origResourceResult = resourceOperation
+ .getResource(resultResource2.getUniqueId());
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */ assertTrue(origResourceResult.isRight());
+
+ }
+
+ /**** SERVICE ***/
+ @Test
+ public void undoCheckoutNewServiceTest() {
+
+ Service resultResource = createTestService(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ //
+
+ // undo checkout
+ Either<? extends Component, StorageOperationStatus> undoCheckoutResponse = lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Service, resultResource, adminUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ Either<Service, StorageOperationStatus> origResourceResult = serviceOperation.getService(origUniqueId);
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */ assertTrue(origResourceResult.isRight());
+
+ }
+
+ @Test
+ public void undoCheckoutNewFullServiceTest() {
+
+ Service origService = createTestService(checkinUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ String origUniqueId = origService.getUniqueId();
+
+ // add artifacts
+ addArtifactToService(checkinUser.getUserId(), origService.getUniqueId(), "install_apache");
+ addArtifactToService(checkinUser.getUserId(), origService.getUniqueId(), "start_apache");
+
+ // add resource instances
+ ResourceInstanceOperationTest riTest = new ResourceInstanceOperationTest();
+ riTest.setOperations(titanGenericDao, capabilityTypeOperation, requirementOperation, capabilityOperation,
+ resourceOperation, propertyOperation, resourceInstanceOperation);
+ riTest.addResourceInstancesAndRelation(origService.getUniqueId());
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ Either<Service, StorageOperationStatus> service = serviceOperation.getService(origUniqueId);
+ assertTrue(service.isLeft());
+
+ Service resultResource = service.left().value();
+ List<ComponentInstance> resourceInstances = resultResource.getComponentInstances();
+
+ // undo checkout
+ Either<? extends Component, StorageOperationStatus> undoCheckoutResponse = lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Service, resultResource, adminUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ Either<Service, StorageOperationStatus> origResourceResult = serviceOperation.getService(origUniqueId);
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */ assertTrue(origResourceResult.isRight());
+
+ for (ComponentInstance ri : resourceInstances) {
+ Either<ComponentInstanceData, TitanOperationStatus> node = titanGenericDao.getNode(
+ UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), ri.getUniqueId(),
+ ComponentInstanceData.class);
+ assertTrue(node.isRight());
+ }
+
+ }
+
+ @Test
+ public void undoCheckoutExistingServiceTest() {
+
+ Service resultResource = createTestService(adminUser.getUserId(), "0.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(resultResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ String prevResourceId = resultResource.getUniqueId();
+ Either<? extends Component, StorageOperationStatus> result2 = lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Service, resultResource, checkoutUser, resourceOwner, false);
+ assertEquals("check resource created", true, result2.isLeft());
+ Component resultResource2 = result2.left().value();
+ String result2Uid = resultResource.getUniqueId();
+
+ // get resource owner
+ getOwnerResponse = lifecycleOperation.getComponentOwner(resultResource2.getUniqueId(), NodeTypeEnum.Resource,
+ false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ resourceOwner = getOwnerResponse.left().value();
+ assertEquals(resourceOwner, checkoutUser);
+
+ // undo checkout
+ Either<? extends Component, StorageOperationStatus> undoCheckoutResponse = lifecycleOperation
+ .undoCheckout(NodeTypeEnum.Service, resultResource2, checkoutUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft());
+
+ // get previous resource
+ Either<Service, StorageOperationStatus> resourceAfterUndo = serviceOperation.getService(prevResourceId);
+ assertTrue(resourceAfterUndo.isLeft());
+ Service actualResource = resourceAfterUndo.left().value();
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(adminUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(adminUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals("0.1", actualResource.getVersion());
+ assertEquals(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, actualResource.getLifecycleState());
+
+ Either<Service, StorageOperationStatus> origResourceResult = serviceOperation.getService(result2Uid);
+ /*
+ * assertTrue(origResourceResult.isLeft());
+ * assertTrue(origResourceResult.left().value().getIsDeleted() == true);
+ */ assertTrue(origResourceResult.isRight());
+
+ }
+
+ /****************************
+ * CERTIFICATION REQUEST
+ ********************************************************************/
+
+ @Test
+ public void certReqDefaultTest() {
+ Resource actualResource = testCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(adminUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ @Test
+ public void atomicCheckinCertReqTest() {
+ Resource actualResource = testCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ private Resource testCertificationRequest(LifecycleStateEnum preState) {
+
+ Resource resultResource = createTestResource(adminUser.getUserId(), "0.1", preState, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<Resource, StorageOperationStatus> certReqResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, certReqResponse.isLeft());
+ Resource resourceAfterChange = certReqResponse.left().value();
+
+ assertEquals(resourceAfterChange.getLifecycleState(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ assertEquals(resourceAfterChange.getVersion(), "0.1");
+ assertEquals(resourceAfterChange.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(resourceAfterChange.getLastUpdaterUserId(), rfcUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(resourceAfterChange.getUniqueId(), NodeTypeEnum.Resource, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(rfcUser));
+
+ return resourceAfterChange;
+ }
+
+ /** SERVICE **/
+ @Test
+ public void certServiceReqDefaultTest() {
+ Service actualResource = testServiceCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+
+ // assert relations
+ ServiceMetadataDataDefinition metadata = new ServiceMetadataDataDefinition();
+ metadata.setUniqueId(actualResource.getUniqueId());
+ ServiceMetadataData serviceData = new ServiceMetadataData(metadata);
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(serviceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(serviceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(adminUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ @Test
+ public void atomicServiceCheckinCertReqTest() {
+ Service actualResource = testServiceCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ // assert relations
+ ServiceMetadataDataDefinition metadata = new ServiceMetadataDataDefinition();
+ metadata.setUniqueId(actualResource.getUniqueId());
+ ServiceMetadataData serviceData = new ServiceMetadataData(metadata);
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(serviceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(serviceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ private Service testServiceCertificationRequest(LifecycleStateEnum preState) {
+
+ Service resultResource = createTestService(adminUser.getUserId(), "0.1", preState, null);
+ String origUniqueId = resultResource.getUniqueId();
+
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId,
+ NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+
+ // checkin
+ Either<? extends Component, StorageOperationStatus> certReqResponse = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultResource, rfcUser, resourceOwner, false);
+ assertEquals("check resource object is returned", true, certReqResponse.isLeft());
+ Service resourceAfterChange = (Service) certReqResponse.left().value();
+
+ assertEquals(resourceAfterChange.getLifecycleState(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ assertEquals(resourceAfterChange.getVersion(), "0.1");
+ assertEquals(resourceAfterChange.getCreatorUserId(), adminUser.getUserId());
+ assertEquals(resourceAfterChange.getLastUpdaterUserId(), rfcUser.getUserId());
+
+ // assert owner changed
+ Either<User, StorageOperationStatus> getOwnerCheckoutResponse = lifecycleOperation
+ .getComponentOwner(resourceAfterChange.getUniqueId(), NodeTypeEnum.Service, false);
+ assertEquals("check user object is returned", true, getOwnerCheckoutResponse.isLeft());
+ resourceOwner = getOwnerCheckoutResponse.left().value();
+ assertTrue(resourceOwner.equals(rfcUser));
+
+ return resourceAfterChange;
+ }
+
+ /****************************
+ * START CERTIFICATION
+ ********************************************************************/
+
+ @Test
+ public void startCertificationTest() {
+
+ Resource resultResource = createTestResource(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<Resource, StorageOperationStatus> requestCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<Resource, StorageOperationStatus> startCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false);
+
+ assertEquals(true, startCertificationResult.isLeft());
+ Resource actualResource = startCertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(testerUser.getUserId(), resourceOwner.getUserId());
+
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, actualResource.getLifecycleState());
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(testerUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /** SERVICE */
+ @Test
+ public void startServiceCertificationTest() {
+
+ Service resultResource = createTestService(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<? extends Component, StorageOperationStatus> requestCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultResource, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<? extends Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultResource, testerUser, rfcUser, false);
+
+ assertEquals(true, startCertificationResult.isLeft());
+ Service actualResource = (Service) startCertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualResource.getUniqueId(), NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(testerUser.getUserId(), resourceOwner.getUserId());
+
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS, actualResource.getLifecycleState());
+
+ // assert relations
+ ServiceMetadataDataDefinition metadata = new ServiceMetadataDataDefinition();
+ metadata.setUniqueId(actualResource.getUniqueId());
+ ServiceMetadataData serviceData = new ServiceMetadataData(metadata);
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(serviceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(testerUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(serviceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(serviceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /****************************
+ * FAIL CERTIFICATION
+ ********************************************************************/
+
+ @Test
+ public void failCertificationTest() {
+
+ Resource actualResource = certificationStatusChange(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, checkinUser);
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ // new state is checkin
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /*** SERVICE **/
+
+ @Test
+ public void failCertificationServiceTest() {
+
+ Service actualService = certificationStatusChangeService(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, checkinUser);
+
+ // assert relations
+ ServiceMetadataData resourceData = new ServiceMetadataData((ServiceMetadataDataDefinition) actualService
+ .getComponentMetadataDefinition().getMetadataDataDefinition());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ // new state is checkin
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /****************************
+ * CANCEL CERTIFICATION
+ ********************************************************************/
+
+ @Test
+ public void cancelCertificationTest() {
+
+ Resource actualResource = certificationStatusChange(LifecycleStateEnum.READY_FOR_CERTIFICATION, rfcUser);
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ // new state is rfc
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /** SERVICE **/
+ @Test
+ public void cancelCertificationServiceTest() {
+
+ Service actualService = certificationStatusChangeService(LifecycleStateEnum.READY_FOR_CERTIFICATION, rfcUser);
+
+ // assert relations
+ ServiceMetadataData ServiceNode = new ServiceMetadataData();
+ ServiceNode.getMetadataDataDefinition().setUniqueId(actualService.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(ServiceNode, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(ServiceNode,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(checkinUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ // new state is rfc
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(ServiceNode, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+ }
+
+ /**************************** CERTIFY ********************************************************************/
+
+ @Test
+ public void certifyTest() {
+
+ Resource resultResource = createTestResource(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<Resource, StorageOperationStatus> requestCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<Resource, StorageOperationStatus> startCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false);
+ assertEquals(true, startCertificationResult.isLeft());
+ Resource actualResource = startCertificationResult.left().value();
+
+ // cancel certification
+ Either<? extends Component, StorageOperationStatus> CertificationResult = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Resource, actualResource, testerUser, testerUser, false);
+
+ assertEquals(true, CertificationResult.isLeft());
+ actualResource = (Resource) CertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(testerUser.getUserId(), resourceOwner.getUserId());
+
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals(LifecycleStateEnum.CERTIFIED, actualResource.getLifecycleState());
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ // new state is certified
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(testerUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ /******** SERVICE **/
+
+ @Test
+ public void certifyServiceTest() {
+
+ Service resultService = createTestService(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<? extends Component, StorageOperationStatus> requestCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<? extends Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService, testerUser, rfcUser, false);
+ assertEquals(true, startCertificationResult.isLeft());
+ Service actualService = (Service) startCertificationResult.left().value();
+
+ // cancel certification
+ Either<? extends Component, StorageOperationStatus> CertificationResult = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, actualService, testerUser, testerUser, false);
+
+ assertEquals(true, CertificationResult.isLeft());
+ actualService = (Service) CertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualService.getUniqueId(), NodeTypeEnum.Service, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(testerUser.getUserId(), resourceOwner.getUserId());
+
+ assertTrue(actualService.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualService.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualService.getLastUpdaterUserId());
+ assertEquals(LifecycleStateEnum.CERTIFIED, actualService.getLifecycleState());
+
+ // assert relations
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(actualService.getUniqueId());
+ Map<String, Object> props = new HashMap<String, Object>();
+
+ // old edges removed
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+ Either<GraphRelation, TitanOperationStatus> incomingRelationByCriteria = titanGenericDao
+ .getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isRight());
+
+ // new state is certified
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData, GraphEdgeLabels.STATE,
+ props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(testerUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+ incomingRelationByCriteria = titanGenericDao.getIncomingRelationByCriteria(resourceData,
+ GraphEdgeLabels.LAST_STATE, props);
+ assertTrue(incomingRelationByCriteria.isLeft());
+ assertEquals(rfcUser.getUserId(), incomingRelationByCriteria.left().value().getFrom().getIdValue());
+
+ }
+
+ @Test
+ public void testDeleteOldVersionsResource() {
+ // simulate
+ createTestResource(checkinUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null);
+ Resource resourceNewVersion = createTestResource(checkinUser.getUserId(), "1.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ createTestResource(checkinUser.getUserId(), "1.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN,
+ resourceNewVersion.getUUID());
+ createTestResource(checkinUser.getUserId(), "1.3", LifecycleStateEnum.CERTIFICATION_IN_PROGRESS,
+ resourceNewVersion.getUUID());
+ Resource certifiedResource = createTestResource(checkinUser.getUserId(), "2.0", LifecycleStateEnum.CERTIFIED,
+ resourceNewVersion.getUUID());
+
+ Either<Boolean, StorageOperationStatus> deleteOldComponentVersions = lifecycleOperation
+ .deleteOldComponentVersions(NodeTypeEnum.Resource, certifiedResource.getName(),
+ certifiedResource.getUUID(), false);
+
+ assertTrue(deleteOldComponentVersions.isLeft());
+
+ String resourceName = certifiedResource.getName();
+ Either<List<Resource>, StorageOperationStatus> resource = resourceOperation
+ .getResourceByNameAndVersion(resourceName, "1.0", false);
+ assertTrue(resource.isLeft());
+
+ resource = resourceOperation.getResourceByNameAndVersion(resourceName, "2.0", false);
+ assertTrue(resource.isLeft());
+
+ resource = resourceOperation.getResourceByNameAndVersion(resourceName, "1.1", false);
+ assertTrue(resource.isLeft());
+ assertTrue(resource.left().value().size() == 1);
+ Resource deleted = resource.left().value().get(0);
+ assertTrue(deleted.getIsDeleted());
+ // assertEquals(StorageOperationStatus.NOT_FOUND,
+ // resource.right().value());
+
+ resource = resourceOperation.getResourceByNameAndVersion(resourceName, "1.2", false);
+ // assertTrue(resource.isRight());
+ // assertEquals(StorageOperationStatus.NOT_FOUND,
+ // resource.right().value());
+ assertTrue(resource.isLeft());
+ assertTrue(resource.left().value().size() == 1);
+ deleted = resource.left().value().get(0);
+ assertTrue(deleted.getIsDeleted());
+
+ resource = resourceOperation.getResourceByNameAndVersion(resourceName, "1.3", false);
+ // assertTrue(resource.isRight());
+ // assertEquals(StorageOperationStatus.NOT_FOUND,
+ // resource.right().value());
+ assertTrue(resource.isLeft());
+ assertTrue(resource.left().value().size() == 1);
+ deleted = resource.left().value().get(0);
+ assertTrue(deleted.getIsDeleted());
+ }
+
+ @Test
+ public void testDeleteOldVersionsService() {
+ // simulate
+ createTestService(checkinUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null);
+ Service serviceNewUUid = createTestService(checkinUser.getUserId(), "1.1",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+ createTestService(checkinUser.getUserId(), "1.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN,
+ serviceNewUUid.getUUID());
+ createTestService(checkinUser.getUserId(), "1.3", LifecycleStateEnum.CERTIFICATION_IN_PROGRESS,
+ serviceNewUUid.getUUID());
+ Service certifiedService = createTestService(checkinUser.getUserId(), "2.0", LifecycleStateEnum.CERTIFIED,
+ serviceNewUUid.getUUID());
+
+ Either<Boolean, StorageOperationStatus> deleteOldComponentVersions = lifecycleOperation
+ .deleteOldComponentVersions(NodeTypeEnum.Service, certifiedService.getName(),
+ certifiedService.getUUID(), false);
+
+ assertTrue(deleteOldComponentVersions.isLeft());
+
+ String resourceName = certifiedService.getName();
+ Either<Service, StorageOperationStatus> service = serviceOperation.getServiceByNameAndVersion(resourceName,
+ "1.0", null, false);
+ assertTrue(service.isLeft());
+
+ service = serviceOperation.getServiceByNameAndVersion(resourceName, "2.0", null, false);
+ assertTrue(service.isLeft());
+
+ service = serviceOperation.getServiceByNameAndVersion(resourceName, "1.1", null, false);
+ /*
+ * assertTrue(resource.isRight());
+ * assertEquals(StorageOperationStatus.NOT_FOUND,
+ * resource.right().value());
+ */
+ assertTrue(service.isLeft());
+ assertTrue(service.left().value().getIsDeleted());
+
+ service = serviceOperation.getServiceByNameAndVersion(resourceName, "1.2", null, false);
+
+ service = serviceOperation.getServiceByNameAndVersion(resourceName, "1.3", null, false);
+ /*
+ * assertTrue(service.isRight());
+ * assertEquals(StorageOperationStatus.NOT_FOUND,
+ * service.right().value());
+ */
+ assertTrue(service.isLeft());
+ assertTrue(service.left().value().getIsDeleted());
+
+ service = serviceOperation.getServiceByNameAndVersion(resourceName, "1.3", null, false);
+ /*
+ * assertTrue(service.isRight());
+ * assertEquals(StorageOperationStatus.NOT_FOUND,
+ * service.right().value());
+ */
+ assertTrue(service.isLeft());
+ assertTrue(service.left().value().getIsDeleted());
+
+ }
+
+ private Resource certificationStatusChange(LifecycleStateEnum nextState, User expectedOwner) {
+ Resource resultResource = createTestResource(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<Resource, StorageOperationStatus> requestCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<Resource, StorageOperationStatus> startCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false);
+ assertEquals(true, startCertificationResult.isLeft());
+ Resource actualResource = startCertificationResult.left().value();
+
+ // cancel certification
+ Either<Resource, StorageOperationStatus> failCertificationResult = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .cancelOrFailCertification(NodeTypeEnum.Resource, actualResource, testerUser, testerUser, nextState,
+ false);
+
+ assertEquals(true, failCertificationResult.isLeft());
+ actualResource = failCertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualResource.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(expectedOwner, resourceOwner);
+
+ assertTrue(actualResource.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualResource.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualResource.getLastUpdaterUserId());
+ assertEquals(nextState, actualResource.getLifecycleState());
+ return actualResource;
+ }
+
+ private Service certificationStatusChangeService(LifecycleStateEnum nextState, User expectedOwner) {
+ Service resultService = createTestService(checkinUser.getUserId(), "0.2",
+ LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null);
+
+ // certification request
+ Either<? extends Component, StorageOperationStatus> requestCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService, rfcUser, checkinUser, false);
+ assertTrue(requestCertificationResult.isLeft());
+
+ // start certification
+ Either<? extends Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService, testerUser, rfcUser, false);
+ assertEquals(true, startCertificationResult.isLeft());
+ Service actualService = (Service) startCertificationResult.left().value();
+
+ // cancel certification
+ Either<? extends Component, StorageOperationStatus> failCertificationResult = lifecycleOperation
+ .cancelOrFailCertification(NodeTypeEnum.Service, actualService, testerUser, testerUser, nextState,
+ false);
+
+ assertEquals(true, failCertificationResult.isLeft());
+ actualService = (Service) failCertificationResult.left().value();
+
+ // get resource owner
+ Either<User, StorageOperationStatus> getOwnerResponse = lifecycleOperation
+ .getComponentOwner(actualService.getUniqueId(), NodeTypeEnum.Resource, false);
+
+ assertEquals("check user object is returned", true, getOwnerResponse.isLeft());
+ User resourceOwner = getOwnerResponse.left().value();
+ assertEquals(expectedOwner, resourceOwner);
+
+ assertTrue(actualService.isHighestVersion());
+ assertEquals(checkinUser.getUserId(), actualService.getCreatorUserId());
+ assertEquals(testerUser.getUserId(), actualService.getLastUpdaterUserId());
+ assertEquals(nextState, actualService.getLifecycleState());
+ return actualService;
+ }
+
+ private Resource createTestResource(String userId, String version, LifecycleStateEnum state, String uuid) {
+ // create resource in graph
+
+ Resource resource2 = buildResourceMetadata(userId, CATEGORY_NAME);
+ resource2.setVersion(version);
+ ;
+ resource2.setLifecycleState(state);
+ resource2.setUUID(uuid);
+
+ Either<Resource, StorageOperationStatus> result = resourceOperation.createResource(resource2);
+ assertEquals("check resource created", true, result.isLeft());
+ Resource resultResource = result.left().value();
+ return resultResource;
+ }
+
+ private Service createTestService(String userId, String version, LifecycleStateEnum state, String uuid) {
+ // create resource in graph
+
+ Service service = new Service();
+ service.setName(SERVICE_NAME);
+ service.setVersion(version);
+ service.setDescription("description 1");
+ service.setCreatorUserId(userId);
+ service.setContactId("contactId@sdc.com");
+ CategoryDefinition category = new CategoryDefinition();
+ category.setName(CATEGORY_NAME);
+
+ List<CategoryDefinition> categories = new ArrayList<>();
+ categories.add(category);
+ service.setCategories(categories);
+ service.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ service.setTags(tags);
+ service.setUUID(uuid);
+
+ service.setLifecycleState(state);
+
+ Either<Service, StorageOperationStatus> result = serviceOperation.createService(service);
+ assertEquals("check service created", true, result.isLeft());
+ Service resultResource = result.left().value();
+ return resultResource;
+ }
+
+ private Resource createFullTestResource(String userId, String version, LifecycleStateEnum state) {
+
+ Resource resource2 = buildResourceMetadata(userId, CATEGORY_NAME);
+ resource2.setVersion(version);
+ ;
+ resource2.setLifecycleState(state);
+
+ InterfaceDefinition inter = new InterfaceDefinition(INTERFACE_NAME, "interface description", null);
+
+ Operation operation = new Operation();
+ operation.setDescription("op description");
+ operation.setUniqueId(inter.getUniqueId() + "." + INTERFACE_OPERATION_CREATE);
+
+ ArtifactDataDefinition artifactDataDef = new ArtifactDataDefinition();
+ artifactDataDef.setArtifactChecksum("YTg2Mjg4MWJhNmI5NzBiNzdDFkMWI=");
+ artifactDataDef.setArtifactName("create_myRoot.sh");
+ artifactDataDef.setArtifactLabel("create_myRoot");
+ artifactDataDef.setArtifactType("SHELL");
+ artifactDataDef.setDescription("good description");
+ artifactDataDef.setEsId("esId");
+ artifactDataDef.setUniqueId(operation.getUniqueId() + "." + artifactDataDef.getArtifactLabel());
+ ArtifactDefinition artifactDef = new ArtifactDefinition(artifactDataDef, "UEsDBAoAAAAIAAeLb0bDQz");
+
+ operation.setImplementation(artifactDef);
+ operation.setCreationDate(System.currentTimeMillis());
+ Map<String, Operation> ops = new HashMap<>();
+ ops.put(INTERFACE_OPERATION_CREATE, operation);
+ inter.setOperations(ops);
+
+ Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+ interfaces.put(INTERFACE_NAME, inter);
+
+ resource2.setInterfaces(interfaces);
+
+ String capabilityTypeName = CAPABILITY_HOSTED_ON;
+ createCapabilityOnGraph(capabilityTypeName);
+
+ // create capability definition
+ CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setDescription("my capability");
+ capabilityDefinition.setType(capabilityTypeName);
+ capabilityDefinition.setName(CAPABILITY_NAME);
+ Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
+ List<String> validSourceTypes = new ArrayList<String>();
+ validSourceTypes.add("tosca.nodes.SC");
+ capabilityDefinition.setValidSourceTypes(validSourceTypes);
+ List<CapabilityDefinition> caplist = new ArrayList<CapabilityDefinition>();
+ caplist.add(capabilityDefinition);
+ capabilities.put(capabilityTypeName, caplist);
+ resource2.setCapabilities(capabilities);
+
+ // add requirement definition
+ RequirementDefinition reqDefinition = new RequirementDefinition();
+ // reqDefinition.setNode(reqNodeName);
+ // reqDefinition.setRelationship(reqRelationship);
+
+ reqDefinition.setCapability(capabilityTypeName);
+ reqDefinition.setName(REQUIREMENT_NAME);
+ Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+ List<RequirementDefinition> reqlist = new ArrayList<RequirementDefinition>();
+ reqlist.add(reqDefinition);
+ requirements.put(capabilityTypeName, reqlist);
+ resource2.setRequirements(requirements);
+
+ Either<Resource, StorageOperationStatus> result = resourceOperation.createResource(resource2);
+ assertEquals("check resource created", true, result.isLeft());
+ Resource resultResource = result.left().value();
+
+ // add artifacts to resource
+ // ArtifactDataDefinition artifactDataDef = new
+ // ArtifactDataDefinition();
+ artifactDataDef.setArtifactChecksum("YTg2Mjg4MWJhNmI5NzBiNzdDFkMWI=");
+ artifactDataDef.setArtifactName("create_myRoot.sh");
+ artifactDataDef.setArtifactLabel("create_myRoot");
+ artifactDataDef.setArtifactType("SHELL");
+ artifactDataDef.setDescription("good description");
+ artifactDataDef.setEsId("esId");
+ artifactDataDef.setUniqueId(resultResource.getUniqueId() + "." + artifactDataDef.getArtifactLabel());
+ artifactDef = new ArtifactDefinition(artifactDataDef, "UEsDBAoAAAAIAAeLb0bDQz");
+ // artifacts.put("myArtifact", artifactDef);
+ // resource2.setArtifacts(artifacts);
+
+ Either<ArtifactDefinition, StorageOperationStatus> addArifactToResource = artifactOperation
+ .addArifactToComponent(artifactDef, resultResource.getUniqueId(), NodeTypeEnum.Resource, false, true);
+ assertTrue(addArifactToResource.isLeft());
+
+ Either<Resource, StorageOperationStatus> resource = resourceOperation.getResource(resultResource.getUniqueId());
+ assertTrue(resource.isLeft());
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(resource.left().value());
+ log.debug(json);
+ return resource.left().value();
+ }
+
+ private void createCapabilityOnGraph(String capabilityTypeName) {
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setDescription("desc1");
+ capabilityTypeDefinition.setType(capabilityTypeName);
+ Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
+ String propName1 = "disk_size";
+ PropertyDefinition property1 = buildProperty1();
+ properties.put(propName1, property1);
+ capabilityTypeDefinition.setProperties(properties);
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition);
+ assertTrue(addCapabilityType1.isLeft());
+ }
+
+ private User convertUserDataToUser(UserData modifierData) {
+ User modifier = new User();
+ modifier.setUserId(modifierData.getUserId());
+ modifier.setEmail(modifierData.getEmail());
+ modifier.setFirstName(modifierData.getFirstName());
+ modifier.setLastName(modifierData.getLastName());
+ modifier.setRole(modifierData.getRole());
+ return modifier;
+ }
+
+ private Resource buildResourceMetadata(String userId, String category) {
+ // deleteAndCreateCategory(category);
+
+ Resource resource = new Resource();
+ resource.setName("my-resource");
+ resource.setVersion("1.0");
+ ;
+ resource.setDescription("description 1");
+ resource.setAbstract(false);
+ resource.setCreatorUserId(userId);
+ resource.setContactId("contactId@sdc.com");
+ resource.setVendorName("vendor 1");
+ resource.setVendorRelease("1.0.0");
+ String[] categoryArr = category.split("/");
+ resource.addCategory(categoryArr[0], categoryArr[1]);
+ resource.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ resource.setTags(tags);
+ return resource;
+ }
+
+ public UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+ userData.setRole(role);
+
+ titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanGenericDao.createNode(userData, UserData.class);
+ titanGenericDao.commit();
+
+ return userData;
+ }
+
+ private PropertyDefinition buildProperty1() {
+ PropertyDefinition property1 = new PropertyDefinition();
+ property1.setDefaultValue("10");
+ property1.setDescription(
+ "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
+ property1.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
+ GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
+ constraints.add(propertyConstraint1);
+
+ LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
+ constraints.add(propertyConstraint2);
+
+ property1.setConstraints(constraints);
+ return property1;
+ }
+
+ private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
+ ArtifactDefinition artifactInfo = new ArtifactDefinition();
+
+ artifactInfo.setArtifactName(artifactName + ".sh");
+ artifactInfo.setArtifactType("SHELL");
+ artifactInfo.setDescription("hdkfhskdfgh");
+ artifactInfo.setPayloadData("UEsDBAoAAAAIAAeLb0bDQz");
+
+ artifactInfo.setUserIdCreator(userId);
+ String fullName = "Jim H";
+ artifactInfo.setUpdaterFullName(fullName);
+ long time = System.currentTimeMillis();
+ artifactInfo.setCreatorFullName(fullName);
+ artifactInfo.setCreationDate(time);
+ artifactInfo.setLastUpdateDate(time);
+ artifactInfo.setUserIdLastUpdater(userId);
+ artifactInfo.setArtifactLabel(artifactName);
+ artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation
+ .addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
+ assertTrue(artifact.isLeft());
+ return artifactInfo;
+ }
+
+}
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
new file mode 100644
index 0000000000..5bd6c831a5
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java
@@ -0,0 +1,120 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Iterator;
+
+import javax.annotation.Resource;
+
+import org.apache.commons.lang.StringUtils;
+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.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PolicyTypeDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.PolicyTypeOperation;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+
+public class PolicyTypeOperationTest extends ModelTestBase {
+
+ @Resource(name = "policy-type-operation")
+ private PolicyTypeOperation policyTypeOperation;
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ ModelTestBase.init();
+
+ }
+
+ @Before
+ public void cleanUp() {
+ TitanGenericDao titanGenericDao = policyTypeOperation.titanGenericDao;
+ Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
+ TitanGraph graph = graphResult.left().value();
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ TitanVertex vertex = iterator.next();
+ vertex.remove();
+ }
+
+ }
+ titanGenericDao.commit();
+ }
+
+ @Test
+ public void testAddPolicyType() {
+
+ PolicyTypeDefinition policyTypePreCreate = createPolicyTypeDef();
+ assertTrue(StringUtils.isEmpty(policyTypePreCreate.getUniqueId()));
+ Either<PolicyTypeDefinition, StorageOperationStatus> addPolicyType = policyTypeOperation
+ .addPolicyType(policyTypePreCreate);
+ assertTrue(addPolicyType.isLeft());
+ PolicyTypeDefinition policyTypePostCreate = addPolicyType.left().value();
+ assertEquals(policyTypePostCreate.getType(), policyTypePreCreate.getType());
+ assertEquals(policyTypePostCreate.getDescription(), policyTypePreCreate.getDescription());
+
+ assertTrue(!StringUtils.isEmpty(policyTypePostCreate.getUniqueId()));
+ }
+
+ @Test
+ public void testGetLatestPolicyTypeByType() {
+ PolicyTypeDefinition policyTypeCreated = policyTypeOperation.addPolicyType(createPolicyTypeDef()).left()
+ .value();
+ Either<PolicyTypeDefinition, StorageOperationStatus> eitherPolicyTypeFetched = policyTypeOperation
+ .getLatestPolicyTypeByType(policyTypeCreated.getType());
+ assertTrue(eitherPolicyTypeFetched.isLeft());
+ PolicyTypeDefinition policyTypeFetched = eitherPolicyTypeFetched.left().value();
+ assertEquals(policyTypeFetched.toString(), policyTypeCreated.toString());
+
+ }
+
+ private PolicyTypeDefinition createPolicyTypeDef() {
+ PolicyTypeDataDefinition policyTypeDataDefinition = new PolicyTypeDataDefinition();
+ policyTypeDataDefinition
+ .setDescription("description: The TOSCA Policy Type all other TOSCA Policy Types derive from");
+ policyTypeDataDefinition.setType("tosca.policies.Root");
+ PolicyTypeDefinition policyTypeDefinition = new PolicyTypeDefinition(policyTypeDataDefinition);
+ policyTypeDefinition.setHighestVersion(true);
+ policyTypeDefinition.setVersion("1.0");
+ return policyTypeDefinition;
+ }
+
+}
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
new file mode 100644
index 0000000000..6caa3044ad
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java
@@ -0,0 +1,548 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.anyMap;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Before;
+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.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.PropertyRule;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.be.resources.data.PropertyData;
+
+import fj.data.Either;
+
+public class PropertyOperationTest extends ModelTestBase {
+
+ PropertyOperation propertyOperation = new PropertyOperation();
+
+ TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
+
+ @Before
+ public void setup() {
+ propertyOperation.setTitanGenericDao(titanGenericDao);
+
+ }
+
+ /*
+ * @Test public void addPropertyToResourceTest() {
+ *
+ * String propName = "myProp"; PropertyDefinition property =
+ * buildPropertyDefinition(); List<PropertyConstraint> constraints =
+ * buildConstraints(); property.setConstraints(constraints);
+ *
+ * PropertyData propertyData = new PropertyData(property,
+ * propertyOperation.convertConstraintsToString(constraints));
+ *
+ * Either<PropertyData, TitanOperationStatus> either =
+ * Either.left(propertyData);
+ * //when(propertyDao.create((GraphNeighbourTable)anyObject(),
+ * eq(PropertyData.class), eq(NodeTypeEnum.Property))).thenReturn(either);
+ * GraphRelation graphRelation = new GraphRelation(); Either<GraphRelation,
+ * TitanOperationStatus> relationResult = Either.left(graphRelation);
+ *
+ * when(titanGenericDao.createNode((PropertyData)anyObject(),
+ * eq(PropertyData.class))).thenReturn(either);
+ * when(titanGenericDao.createRelation((GraphNode)anyObject(),
+ * (GraphNode)anyObject(), eq(GraphEdgeLabels.PROPERTY),
+ * anyMap())).thenReturn(relationResult);
+ *
+ * Either<PropertyDefinition, StorageOperationStatus> result =
+ * propertyOperation.addPropertyToResource(propName, property,
+ * NodeTypeEnum.Resource, "my-resource.1.0");
+ *
+ * assertTrue(result.isLeft()); System.out.println(result.left().value());
+ * PropertyDefinition propertyDefinition = result.left().value();
+ *
+ * List<PropertyConstraint> originalConstraints = property.getConstraints();
+ * List<PropertyConstraint> propertyConstraintsResult =
+ * propertyDefinition.getConstraints();
+ * assertEquals(propertyConstraintsResult.size(),
+ * originalConstraints.size());
+ *
+ * }
+ */
+ private PropertyDefinition buildPropertyDefinition() {
+ PropertyDefinition property = new PropertyDefinition();
+ property.setDefaultValue("10");
+ property.setDescription(
+ "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
+ property.setType(ToscaType.INTEGER.name().toLowerCase());
+ return property;
+ }
+
+ @Test
+ public void addPropertiesToGraphTableTest() {
+
+ // Map<String, PropertyDefinition> properties = new HashMap<String,
+ // PropertyDefinition>();
+ // String propName = "myProp";
+ // PropertyDefinition property = buildPropertyDefinition();
+ //
+ // List<PropertyConstraint> constraints = buildConstraints();
+ // property.setConstraints(constraints);
+ //
+ // properties.put(propName, property);
+ //
+ // GraphNeighbourTable graphNeighbourTable = new GraphNeighbourTable();
+ // ResourceData resourceData = new ResourceData();
+ // String resourceName = "my-resource";
+ // String resourceVersion = "1.0";
+ // String resourceId = resourceName + "." + resourceVersion;
+ // resourceData.setUniqueId(resourceId);
+ // int resourceIndex = graphNeighbourTable.addNode(resourceData);
+ //
+ // heatParametersOperation.addPropertiesToGraphTable(properties,
+ // graphNeighbourTable, resourceIndex, resourceId);
+ //
+ // assertEquals(2, graphNeighbourTable.getNodes().size());
+ // assertEquals(1, graphNeighbourTable.getDirectedEdges().size());
+ // List<GraphNode> nodes = graphNeighbourTable.getNodes();
+ // boolean nodeFound = false;
+ // for (GraphNode neo4jNode : nodes) {
+ // if (neo4jNode instanceof PropertyData) {
+ // PropertyData propertyData = (PropertyData)neo4jNode;
+ // assertEquals("check property unique id", resourceId + "." + propName,
+ // propertyData.getUniqueId());
+ // assertEquals(property.getDescription(),
+ // propertyData.getPropertyDataDefinition().getDescription());
+ // nodeFound = true;
+ // }
+ // }
+ // assertEquals("looking for PropertyData object in table", true,
+ // nodeFound);
+ //
+ // NodeRelation nodeRelation =
+ // graphNeighbourTable.getDirectedEdges().get(0);
+ // assertEquals("check from index to index edge", 0,
+ // nodeRelation.getFromIndex());
+ // assertEquals("check from index to index edge", 1,
+ // nodeRelation.getToIndex());
+ // assertEquals("check edge type",
+ // GraphEdgePropertiesDictionary.PROPERTY,
+ // nodeRelation.getEdge().getEdgeType());
+ // assertEquals("check propert name on edge", true,
+ // nodeRelation.getEdge().getProperties().values().contains(propName));
+ }
+
+ @Test
+ public void convertConstraintsTest() {
+
+ List<PropertyConstraint> constraints = buildConstraints();
+ List<String> convertedStringConstraints = propertyOperation.convertConstraintsToString(constraints);
+ assertEquals("constraints size", constraints.size(), convertedStringConstraints.size());
+
+ List<PropertyConstraint> convertedConstraints = propertyOperation
+ .convertConstraints(convertedStringConstraints);
+ assertEquals("check size of constraints", constraints.size(), convertedConstraints.size());
+
+ Set<String> constraintsClasses = new HashSet<String>();
+ for (PropertyConstraint propertyConstraint : constraints) {
+ constraintsClasses.add(propertyConstraint.getClass().getName());
+ }
+
+ for (PropertyConstraint propertyConstraint : convertedConstraints) {
+ assertTrue("check all classes generated",
+ constraintsClasses.contains(propertyConstraint.getClass().getName()));
+ }
+ }
+
+ @Test
+ public void testIsPropertyDefaultValueValid_NoDefault() {
+ PropertyDefinition property = new PropertyDefinition();
+ property.setName("myProperty");
+ property.setType(ToscaPropertyType.BOOLEAN.getType());
+ assertTrue(propertyOperation.isPropertyDefaultValueValid(property, null));
+ }
+
+ @Test
+ public void testIsPropertyDefaultValueValid_ValidDefault() {
+ PropertyDefinition property = new PropertyDefinition();
+ property.setName("myProperty");
+ property.setType(ToscaPropertyType.INTEGER.getType());
+ property.setDefaultValue("50");
+ assertTrue(propertyOperation.isPropertyDefaultValueValid(property, null));
+ }
+
+ @Test
+ public void testIsPropertyDefaultValueValid_InvalidDefault() {
+ PropertyDefinition property = new PropertyDefinition();
+ property.setName("myProperty");
+ property.setType(ToscaPropertyType.BOOLEAN.getType());
+ property.setDefaultValue("50");
+ assertFalse(propertyOperation.isPropertyDefaultValueValid(property, null));
+ }
+
+ private List<PropertyConstraint> buildConstraints() {
+ List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
+ GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
+ LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
+ List<String> range = new ArrayList<String>();
+ range.add("0");
+ range.add("100");
+ InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
+ constraints.add(propertyConstraint1);
+ constraints.add(propertyConstraint2);
+ constraints.add(propertyConstraint3);
+ return constraints;
+ }
+
+ @Test
+ public void findPropertyValueBestMatch1() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ ComponentInstanceProperty instanceProperty3 = new ComponentInstanceProperty();
+ instanceProperty3.setValue("v1node3");
+ instanceIdToValue.put("node3", instanceProperty3);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", "v1node1", instanceProperty.getValue());
+ assertEquals("check default value", "v1node2", instanceProperty.getDefaultValue());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatch2() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+ instanceProperty2.setValueUniqueUid("aaaa");
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", "v1node2", instanceProperty.getValue());
+ assertEquals("check default value", "vv1", instanceProperty.getDefaultValue());
+ assertNull("check value unique id is null", instanceProperty.getValueUniqueUid());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatch3() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+ instanceProperty1.setValueUniqueUid("aaaa");
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty3 = new ComponentInstanceProperty();
+ instanceProperty3.setValue("v1node3");
+ instanceIdToValue.put("node3", instanceProperty3);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", "v1node1", instanceProperty.getValue());
+ assertEquals("check default value", "v1node3", instanceProperty.getDefaultValue());
+ assertEquals("check valid unique id", instanceProperty1.getValueUniqueUid(),
+ instanceProperty.getValueUniqueUid());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatch1Rules() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+
+ List<PropertyRule> rules = new ArrayList<>();
+ PropertyRule propertyRule = new PropertyRule();
+ String[] ruleArr = { "node1", ".+", "node3" };
+ List<String> rule1 = new ArrayList<>(Arrays.asList(ruleArr));
+ propertyRule.setRule(rule1);
+ propertyRule.setValue("88");
+ rules.add(propertyRule);
+ instanceProperty1.setRules(rules);
+
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ ComponentInstanceProperty instanceProperty3 = new ComponentInstanceProperty();
+ instanceProperty3.setValue("v1node3");
+ instanceIdToValue.put("node3", instanceProperty3);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", propertyRule.getValue(), instanceProperty.getValue());
+ assertEquals("check default value", "v1node2", instanceProperty.getDefaultValue());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatch2Rules() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+
+ List<PropertyRule> rules = new ArrayList<>();
+ PropertyRule propertyRule1 = new PropertyRule();
+ String[] ruleArr1 = { "node1", "node2", ".+" };
+ List<String> rule1 = new ArrayList<>(Arrays.asList(ruleArr1));
+ propertyRule1.setRule(rule1);
+ propertyRule1.setValue("88");
+
+ PropertyRule propertyRule2 = new PropertyRule();
+ String[] ruleArr2 = { "node1", "node2", "node3" };
+ List<String> rule2 = new ArrayList<>(Arrays.asList(ruleArr2));
+ propertyRule2.setRule(rule2);
+ propertyRule2.setValue("99");
+
+ rules.add(propertyRule2);
+ rules.add(propertyRule1);
+
+ instanceProperty1.setRules(rules);
+
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ ComponentInstanceProperty instanceProperty3 = new ComponentInstanceProperty();
+ instanceProperty3.setValue("v1node3");
+ instanceIdToValue.put("node3", instanceProperty3);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", propertyRule2.getValue(), instanceProperty.getValue());
+ assertEquals("check default value", "v1node2", instanceProperty.getDefaultValue());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatch1RuleLowLevel() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+
+ List<PropertyRule> rules = new ArrayList<>();
+ PropertyRule propertyRule1 = new PropertyRule();
+ String[] ruleArr1 = { "node1", "node2", ".+" };
+ List<String> rule1 = new ArrayList<>(Arrays.asList(ruleArr1));
+ propertyRule1.setRule(rule1);
+ propertyRule1.setValue("88");
+
+ PropertyRule propertyRule2 = new PropertyRule();
+ String[] ruleArr2 = { "node1", "node2", "node3" };
+ List<String> rule2 = new ArrayList<>(Arrays.asList(ruleArr2));
+ propertyRule2.setRule(rule2);
+ propertyRule2.setValue("99");
+
+ rules.add(propertyRule2);
+ rules.add(propertyRule1);
+
+ instanceProperty1.setRules(rules);
+
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+
+ List<PropertyRule> rules3 = new ArrayList<>();
+ PropertyRule propertyRule3 = new PropertyRule();
+ String[] ruleArr3 = { "node2", "node3" };
+ List<String> rule3 = new ArrayList<>(Arrays.asList(ruleArr3));
+ propertyRule3.setRule(rule3);
+ propertyRule3.setValue("77");
+ rules3.add(propertyRule3);
+
+ instanceProperty2.setRules(rules3);
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ ComponentInstanceProperty instanceProperty3 = new ComponentInstanceProperty();
+ instanceProperty3.setValue("v1node3");
+ instanceIdToValue.put("node3", instanceProperty3);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", propertyRule2.getValue(), instanceProperty.getValue());
+ assertEquals("check default value", propertyRule3.getValue(), instanceProperty.getDefaultValue());
+
+ }
+
+ @Test
+ public void findPropertyValueBestMatchDefaultValueNotChanged() {
+
+ String propertyUniqueId = "x1";
+ ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
+ instanceProperty.setValue("v1");
+ instanceProperty.setDefaultValue("vv1");
+ List<String> path = new ArrayList<>();
+ path.add("node1");
+ path.add("node2");
+ path.add("node3");
+ instanceProperty.setPath(path);
+
+ Map<String, ComponentInstanceProperty> instanceIdToValue = new HashMap<String, ComponentInstanceProperty>();
+ ComponentInstanceProperty instanceProperty1 = new ComponentInstanceProperty();
+ instanceProperty1.setValue("v1node1");
+
+ List<PropertyRule> rules = new ArrayList<>();
+ PropertyRule propertyRule1 = new PropertyRule();
+ String[] ruleArr1 = { "node1", "node2", ".+" };
+ List<String> rule1 = new ArrayList<>(Arrays.asList(ruleArr1));
+ propertyRule1.setRule(rule1);
+ propertyRule1.setValue("88");
+
+ PropertyRule propertyRule2 = new PropertyRule();
+ String[] ruleArr2 = { "node1", "node2", "node3" };
+ List<String> rule2 = new ArrayList<>(Arrays.asList(ruleArr2));
+ propertyRule2.setRule(rule2);
+ propertyRule2.setValue("99");
+
+ rules.add(propertyRule2);
+ rules.add(propertyRule1);
+
+ instanceProperty1.setRules(rules);
+
+ instanceIdToValue.put("node1", instanceProperty1);
+
+ ComponentInstanceProperty instanceProperty2 = new ComponentInstanceProperty();
+ instanceProperty2.setValue("v1node2");
+
+ List<PropertyRule> rules3 = new ArrayList<>();
+ PropertyRule propertyRule3 = new PropertyRule();
+ String[] ruleArr3 = { "node2", "node333" };
+ List<String> rule3 = new ArrayList<>(Arrays.asList(ruleArr3));
+ propertyRule3.setRule(rule3);
+ propertyRule3.setValue("77");
+ rules3.add(propertyRule3);
+
+ instanceProperty2.setRules(rules3);
+ instanceIdToValue.put("node2", instanceProperty2);
+
+ propertyOperation.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
+
+ assertEquals("check value", propertyRule2.getValue(), instanceProperty.getValue());
+ assertEquals("check default value", "vv1", instanceProperty.getDefaultValue());
+
+ }
+
+ // add all rule types
+ // add rule with size = 1(instance itself = ALL). relevant for VLi. equals
+ // to X.*.*.* in all paths size
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RequirementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RequirementOperationTest.java
new file mode 100644
index 0000000000..fe4b501148
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RequirementOperationTest.java
@@ -0,0 +1,236 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.config.Configuration;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+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.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.CapabiltyInstance;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.RequirementImplDef;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.RequirementOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.operations.impl.util.PrintGraph;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.common.api.ConfigurationListener;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class RequirementOperationTest extends ModelTestBase {
+ private static Logger log = LoggerFactory.getLogger(RequirementOperationTest.class.getName());
+ private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+
+ private static String USER_ID = "muserId";
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ private static ConfigurationManager configurationManager;
+
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "requirement-operation")
+ private RequirementOperation requirementOperation;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+
+ // configurationManager = new ConfigurationManager(
+ // new ConfigurationSource() {
+ //
+ // @Override
+ // public <T> T getAndWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+ //
+ // @Override
+ // public <T> void addWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ //
+ // }
+ // });
+ //
+ // Configuration configuration = new Configuration();
+ // configuration.setTitanInMemoryGraph(true);
+ //
+ // configurationManager.setConfiguration(configuration);
+ ModelTestBase.init();
+ }
+
+ @Test
+ public void testDummy() {
+
+ assertTrue(requirementOperation != null);
+
+ }
+
+ @Test
+ public void testAddRequirementNotExistCapability() {
+
+ String reqName = "host";
+ RequirementDefinition reqDefinition = new RequirementDefinition();
+ reqDefinition.setNode("tosca.nodes.Compute");
+ reqDefinition.setRelationship("myrelationship");
+ reqDefinition.setCapability("mycapability___2");
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", "0.1", null,
+ true, true);
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation
+ .addRequirementToResource(reqName, reqDefinition, resource.getUniqueId());
+ assertEquals("check error", StorageOperationStatus.INVALID_ID, addRequirementToResource.right().value());
+
+ }
+
+ @Before
+ public void createUserAndCategory() {
+ String[] category = CATEGORY_NAME.split("/");
+ OperationTestsUtil.deleteAndCreateResourceCategory(category[0], category[1], titanDao);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ @Test
+ public void testAddRequirementWithCapability() {
+
+ String capabilityTypeName = "tosca.nodes.Container";
+
+ String reqName = "host";
+ RequirementDefinition reqDefinition = new RequirementDefinition();
+ reqDefinition.setNode("tosca.nodes.Compute");
+ reqDefinition.setRelationship("myrelationship");
+ reqDefinition.setCapability(capabilityTypeName);
+
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+
+ capabilityTypeOperationTest.createCapability(capabilityTypeName);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", "2.0", null,
+ true, true);
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation
+ .addRequirementToResource(reqName, reqDefinition, resource.getUniqueId());
+
+ assertEquals("check requirement was added", true, addRequirementToResource.isLeft());
+
+ Either<Resource, StorageOperationStatus> resource2 = resourceOperation.getResource(resource.getUniqueId());
+ String json = prettyGson.toJson(resource2);
+ log.debug(json);
+ }
+
+ private void compareProperties(Map<String, PropertyDefinition> capabilityProperties,
+ CapabiltyInstance capabiltyInstance, Map<String, String> actual) {
+
+ Map<String, String> properties = capabiltyInstance.getProperties();
+
+ for (Entry<String, PropertyDefinition> entry : capabilityProperties.entrySet()) {
+ String paramName = entry.getKey();
+ PropertyDefinition propertyDefinition = entry.getValue();
+ String defaultValue = propertyDefinition.getDefaultValue();
+
+ String value = properties.get(paramName);
+
+ String actualValue = null;
+ if (actual != null) {
+ actualValue = actual.get(paramName);
+ }
+ if (actualValue != null) {
+ assertEquals("check property value of key " + paramName, value, actualValue);
+ } else {
+ assertEquals("check property value of key " + paramName, value, defaultValue);
+ }
+ }
+
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceInstanceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceInstanceOperationTest.java
new file mode 100644
index 0000000000..bef51f415c
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceInstanceOperationTest.java
@@ -0,0 +1,2511 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+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.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
+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.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.HeatParameterDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.RelationshipImpl;
+import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
+import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
+import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.RequirementOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.operations.impl.util.PrintGraph;
+import org.openecomp.sdc.be.resources.data.ArtifactData;
+import org.openecomp.sdc.be.resources.data.HeatParameterData;
+import org.openecomp.sdc.be.resources.data.HeatParameterValueData;
+import org.openecomp.sdc.be.resources.data.RelationshipInstData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.be.resources.data.UniqueIdData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ResourceInstanceOperationTest extends ModelTestBase {
+ private static Logger log = LoggerFactory.getLogger(ResourceInstanceOperationTest.class.getName());
+ private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+
+ private static String USER_ID = "muserId";
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "requirement-operation")
+ private RequirementOperation requirementOperation;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @javax.annotation.Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation resourceInstanceOperation;
+
+ @javax.annotation.Resource
+ private HeatParametersOperation heatParameterOperation;
+
+ @javax.annotation.Resource
+ private ArtifactOperation artifactOperation;
+
+ private String CAPABILITY_1 = "mycapability101";
+ private String CAPABILITY_2 = "mycapability102";
+
+ private Integer TEST_CLASS_NUMBER = 1;
+
+ public final static Pattern COMPONENT_NAME_DELIMETER_PATTERN = Pattern.compile("[\\.\\-\\_]+");
+
+ public final static Pattern COMPONENT_INCTANCE_NAME_DELIMETER_PATTERN = Pattern.compile("[\\.\\-\\_]+");
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+
+ // configurationManager = new ConfigurationManager(
+ // new ConfigurationSource() {
+ //
+ // @Override
+ // public <T> T getAndWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+ //
+ // @Override
+ // public <T> void addWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ //
+ // }
+ // });
+ //
+ // Configuration configuration = new Configuration();
+ //
+ // ////inmemory
+ // boolean useInMemory = true;
+ // if (useInMemory) {
+ // configuration.setTitanInMemoryGraph(true);
+ // } else {
+ // configuration.setTitanInMemoryGraph(false);
+ // configuration.setTitanCfgFile("C:\\Git_work\\D2-SDnC\\catalog-be\\src\\main\\resources\\config\\titan.properties");
+ // }
+ //
+ //
+ //
+ // configurationManager.setConfiguration(configuration);
+ ModelTestBase.init();
+ }
+
+ public void setOperations(TitanGenericDao titanDao, CapabilityTypeOperation capabilityTypeOperation,
+ RequirementOperation requirementOperation, CapabilityOperation capabilityOperation,
+ ResourceOperation resourceOperation, PropertyOperation propertyOperation,
+ ComponentInstanceOperation resourceInstanceOperation2) {
+ this.titanDao = titanDao;
+ this.capabilityTypeOperation = capabilityTypeOperation;
+ this.capabilityOperation = capabilityOperation;
+ this.requirementOperation = requirementOperation;
+ this.resourceOperation = resourceOperation;
+ this.propertyOperation = propertyOperation;
+ this.resourceInstanceOperation = resourceInstanceOperation2;
+ }
+
+ @Test
+ public void testDummy() {
+
+ assertTrue(requirementOperation != null);
+
+ }
+
+ @Test
+ public void testAddResourceInstanceInvalidServiceId() {
+
+ try {
+ ComponentInstance instance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent("service1", NodeTypeEnum.Service, "1", true, instance,
+ NodeTypeEnum.Resource, false);
+ assertEquals("check failed status - service is not in graph", true, status.isRight());
+ assertEquals("check failed status value - service is not in graph", TitanOperationStatus.INVALID_ID,
+ status.right().value());
+ } finally {
+ titanDao.rollback();
+ }
+
+ }
+
+ @Test
+ public void testAddResourceInstanceValidServiceIdInvalidResourceId() {
+ try {
+
+ ServiceMetadataData serviceData1 = createService("myservice1.1.0");
+
+ ComponentInstance instance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service,
+ "1", true, instance, NodeTypeEnum.Resource, false);
+
+ assertEquals("check failed status - service is not in graph", true, status.isRight());
+ assertEquals("check failed status value - service is not in graph", TitanOperationStatus.INVALID_ID,
+ status.right().value());
+
+ } finally {
+ titanDao.rollback();
+ }
+
+ }
+
+ @Test
+ public void testAddResourceInstanceValidServiceId() {
+ try {
+ String serviceName = "myservice1.1.0";
+ String resourceName = "tosca.nodes.Apache.2.0";
+ ServiceMetadataData serviceData1 = createService(serviceName);
+ ResourceMetadataData resourceData = createResource(resourceName);
+
+ ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(),
+ "1", "tosca.nodes.Apache");
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service,
+ "1", true, instance, NodeTypeEnum.Resource, false);
+
+ assertEquals("check success status - service is not in graph", true, status.isLeft());
+
+ ComponentInstance value = status.left().value();
+ assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
+
+ ServiceMetadataData serviceData2 = deleteService(serviceName);
+ ResourceMetadataData resourceData2 = deleteResource(resourceName);
+
+ } finally {
+ titanDao.rollback();
+ }
+ }
+
+ @Test
+ public void testUpdateResourceInstance() {
+ try {
+ String serviceName = "myservice1.1.0";
+ String resourceName = "tosca.nodes.Apache.2.0";
+ ServiceMetadataData serviceData1 = createService(serviceName);
+ ResourceMetadataData resourceData = createResource(resourceName);
+
+ ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(),
+ "1", "tosca.nodes.Apache");
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service,
+ "1", true, instance, NodeTypeEnum.Resource, false);
+
+ ComponentInstance resourceInstance = status.left().value();
+ Long creationTime = resourceInstance.getCreationTime();
+ String name = resourceInstance.getName();
+ assertEquals("check success status - service is not in graph", true, status.isLeft());
+
+ ComponentInstance value = status.left().value();
+ assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
+
+ Either<ComponentInstance, StorageOperationStatus> u1Res = resourceInstanceOperation.updateResourceInstance(
+ (String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value,
+ true);
+ assertTrue("check update succeed", u1Res.isLeft());
+
+ Long lastModificationTimeNC = value.getModificationTime();
+ String desc = "AAAAA";
+ String posX = "15";
+ String posY = "12";
+ String updatedName = "Shlokshlik";
+ value.setDescription(desc);
+ value.setPosX(posX);
+ Either<ComponentInstance, StorageOperationStatus> u2Res = resourceInstanceOperation.updateResourceInstance(
+ (String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value,
+ true);
+ assertTrue("check update succeed", u2Res.isLeft());
+ assertEquals("check resource instance updated", desc, u2Res.left().value().getDescription());
+ assertEquals("check resource instance updated", posX, u2Res.left().value().getPosX());
+ assertEquals("check resource instance updated", resourceInstance.getPosY(), u2Res.left().value().getPosY());
+ assertEquals("check modification time was not updated since it was supplied",
+ u2Res.left().value().getModificationTime(), lastModificationTimeNC);
+
+ Long lastModificationTime = value.getModificationTime();
+ value.setPosY(posY);
+ value.setModificationTime(null);
+ value.setName(updatedName);
+ Either<ComponentInstance, StorageOperationStatus> u3Res = resourceInstanceOperation.updateResourceInstance(
+ (String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value,
+ true);
+ assertTrue("check update succeed", u3Res.isLeft());
+ assertEquals("check resource instance updated", desc, u3Res.left().value().getDescription());
+ assertEquals("check resource pos x updated", posX, u3Res.left().value().getPosX());
+ assertEquals("check resource pos y updated", posY, u3Res.left().value().getPosY());
+ assertTrue("check modification time was updated",
+ u3Res.left().value().getModificationTime() >= lastModificationTime);
+ assertEquals("check creation time was not updated", creationTime, u3Res.left().value().getCreationTime());
+ assertEquals("check name was updated", updatedName, u3Res.left().value().getName());
+
+ ServiceMetadataData serviceData2 = deleteService(serviceName);
+ ResourceMetadataData resourceData2 = deleteResource(resourceName);
+
+ } finally {
+ titanDao.rollback();
+ }
+ }
+
+ @Test
+ public void testRemoveResourceInstance() {
+ try {
+ String serviceName = "myservice1.1.0";
+ String resourceName = "tosca.nodes.Apache.2.0";
+ ServiceMetadataData serviceData1 = createService(serviceName);
+ ResourceMetadataData resourceData = createResource(resourceName);
+
+ ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(),
+ "1", "tosca.nodes.Apache");
+
+ Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service,
+ "1", true, instance, NodeTypeEnum.Resource, false);
+
+ assertEquals("check success status - service is not in graph", true, status.isLeft());
+
+ ComponentInstance value = status.left().value();
+ assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
+
+ Either<ComponentInstance, TitanOperationStatus> status1 = resourceInstanceOperation
+ .removeComponentInstanceFromComponent(NodeTypeEnum.Service, serviceName, value.getUniqueId());
+
+ assertTrue("check resource service was deleted.", status1.isLeft());
+ assertEquals("check resource instance returned.", "tosca.nodes.Apache 1", status1.left().value().getName());
+
+ ServiceMetadataData serviceData2 = deleteService(serviceName);
+ ResourceMetadataData resourceData2 = deleteResource(resourceName);
+
+ } finally {
+ titanDao.rollback();
+ }
+ }
+
+ @Test
+ public void testRemoveResourceInstanceNotFound() {
+ try {
+ String serviceName = "myservice1.1.0";
+ ServiceMetadataData serviceData1 = createService(serviceName);
+
+ Either<ComponentInstance, TitanOperationStatus> status1 = resourceInstanceOperation
+ .removeComponentInstanceFromComponent(NodeTypeEnum.Service, serviceName, "stam");
+
+ assertTrue("check resource service was not deleted.", status1.isRight());
+ assertEquals("check NOT_FOUND returned.", TitanOperationStatus.NOT_FOUND, status1.right().value());
+
+ ServiceMetadataData serviceData2 = deleteService(serviceName);
+
+ } finally {
+ titanDao.rollback();
+ }
+ }
+
+ public ServiceMetadataData createService(String serviceName) {
+
+ ServiceMetadataData serviceData1 = new ServiceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
+ Either<ServiceMetadataData, TitanOperationStatus> createNode = titanDao.createNode(serviceData1,
+ ServiceMetadataData.class);
+
+ assertTrue("check service created", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ public ServiceMetadataData deleteService(String serviceName) {
+
+ ServiceMetadataData serviceData1 = new ServiceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
+ Either<ServiceMetadataData, TitanOperationStatus> createNode = titanDao.deleteNode(serviceData1,
+ ServiceMetadataData.class);
+ assertTrue("check service deleted", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ public ResourceMetadataData createResource(String resourceName) {
+
+ ResourceMetadataData serviceData1 = new ResourceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
+ Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.createNode(serviceData1,
+ ResourceMetadataData.class);
+
+ assertTrue("check service created", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ public ResourceMetadataData deleteResource(String resourceName) {
+
+ ResourceMetadataData serviceData1 = new ResourceMetadataData();
+ serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
+ Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.deleteNode(serviceData1,
+ ResourceMetadataData.class);
+
+ assertTrue("check service created", createNode.isLeft());
+ return createNode.left().value();
+ }
+
+ @Test
+ public void testAddResourceInstanceJson() {
+ addResourceInstanceJson();
+ }
+
+ public ComponentInstance addResourceInstanceJson() {
+
+ ComponentInstance resourceInstance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
+
+ String json = prettyGson.toJson(resourceInstance);
+ log.debug(json);
+
+ return resourceInstance;
+
+ }
+
+ private ComponentInstance buildResourceInstance(String respurceUid, String instanceNumber, String name) {
+ ComponentInstance resourceInstance = new ComponentInstance();
+ // resourceInstance
+ // .setUniqueId("<SN>.tosca.nodes.Apache.2.0." + instanceNumber);
+ resourceInstance.setName(name);
+ resourceInstance.setDescription("desc1");
+ resourceInstance.setPosX("20");
+ resourceInstance.setPosY("40");
+ resourceInstance.setComponentUid(respurceUid);
+ resourceInstance.setCreationTime(System.currentTimeMillis());
+ resourceInstance.setModificationTime(System.currentTimeMillis());
+ resourceInstance.setNormalizedName(normaliseComponentName(name));
+
+ // Map<String, RequirementInstance> requirements = new HashMap<String,
+ // RequirementInstance>();
+ //
+ // RequirementInstance requirementInstance1 = new RequirementInstance();
+ // requirementInstance1.setNode("NA");
+ // RelationshipImpl relationshipImpl = new RelationshipImpl();
+ // relationshipImpl.setType("tosca.relationships.HostedOn");
+ // requirementInstance1.setRelationship(relationshipImpl);
+ //
+ // requirements.put("host", requirementInstance1);
+ //
+ // RequirementInstance requirementInstance2 = new RequirementInstance();
+ // requirementInstance2.setNode("NA");
+ // RelationshipImpl relationshipImpl2 = new RelationshipImpl();
+ // relationshipImpl2.setType("tosca.relationships.LinkTo");
+ // requirementInstance2.setRelationship(relationshipImpl2);
+ //
+ // requirements.put("link", requirementInstance2);
+ //
+ // resourceInstance.setRequirements(requirements);
+ return resourceInstance;
+ }
+
+ @Test
+ public void testConenctResourceInstancesJson() {
+ RequirementCapabilityRelDef addRelationship = addRelationship("apache_1", "compute_100");
+ String json = prettyGson.toJson(addRelationship);
+ log.debug(json);
+
+ RequirementCapabilityRelDef capabilityRelDef = prettyGson.fromJson(json, RequirementCapabilityRelDef.class);
+ log.debug("{}", capabilityRelDef);
+
+ }
+
+ public RequirementCapabilityRelDef addRelationship(String from, String to) {
+ RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
+ requirementCapabilityRelDef.setFromNode(from);
+ requirementCapabilityRelDef.setToNode(to);
+ List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
+
+ String req = "host";
+ RelationshipImpl relationshipImpl = new RelationshipImpl();
+ relationshipImpl.setType("tosca.nodes.HostedOn");
+ RequirementAndRelationshipPair rels = new RequirementAndRelationshipPair(req, relationshipImpl);
+ relationships.add(rels);
+
+ requirementCapabilityRelDef.setRelationships(relationships);
+
+ return requirementCapabilityRelDef;
+ }
+
+ @Before
+ public void createUserAndCategory() {
+ deleteAndCreateCategory(CATEGORY_NAME);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+ OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao);
+
+ /*
+ * CategoryData categoryData = new CategoryData();
+ * categoryData.setName(category);
+ *
+ * titanDao.deleteNode(categoryData, CategoryData.class);
+ * Either<CategoryData, TitanOperationStatus> createNode = titanDao
+ * .createNode(categoryData, CategoryData.class);
+ * System.out.println("after creating caetgory " + createNode);
+ */
+ }
+
+ @Test
+ @Ignore
+ public void testConnectResourceInstances() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+ try {
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName);
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ // rollbackAndPrint();
+
+ // Add capabilities to Compute Resource
+ CapabilityDefinition addCapability = addCapabilityToResource(capabilityTypeName, "host", computeComponent);
+
+ // CapabilityDefinition capabilityDefinition = new
+ // CapabilityDefinition();
+ // capabilityDefinition.setDescription("my capability");
+ // capabilityDefinition.setType(capabilityTypeName);
+ // List<String> validSourceTypes = new ArrayList<String>();
+ // validSourceTypes.add("tosca.nodes.SC");
+ // capabilityDefinition.setValidSourceTypes(validSourceTypes);
+ // Either<CapabilityDefinition, StorageOperationStatus>
+ // addCapability = capabilityOperation
+ // .addCapability(computeComponent.getUniqueId(), "host",
+ // capabilityDefinition, true);
+ // //logger.debug("addCapability result " + addCapability);
+ // assertTrue("check capability created ", addCapability.isLeft());
+ //
+ // =============================================
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource,
+ computeComponent, "host", false, addCapability.getUniqueId(),
+ addRequirementToResource.left().value().getUniqueId());
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ log.debug(webGraph);
+
+ Either<Resource, StorageOperationStatus> resourceFull = resourceOperation
+ .getResource(resource.getUniqueId());
+ assertTrue(resourceFull.isLeft());
+ List<RequirementCapabilityRelDef> componentInstancesRelations = resourceFull.left().value()
+ .getComponentInstancesRelations();
+
+ RequirementCapabilityRelDef capabilityRelDef = componentInstancesRelations.get(0);
+ capabilityRelDef.getRelationships().get(0).setRequirement("host");
+
+ // disconnectResourcesInService(serviceName, resInstances.get(0),
+ // "host");
+ disconnectResourcesInService(serviceName, capabilityRelDef);
+
+ } finally {
+ rollbackAndPrint(false);
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ @Test
+ @Ignore
+ public void testConnectResourceInstances1Requirement2Capabilities() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ try {
+
+ String capabilityTypeName1 = CAPABILITY_1;
+ String capabilityTypeName2 = CAPABILITY_2;
+ String reqName1 = "host1";
+ String reqName2 = "host2";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName1);
+ CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName2);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ // Add capabilities to Compute Resource
+ CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
+ CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
+
+ // rollbackAndPrint();
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
+
+ String requirementId = addRequirementToResource.left().value().getUniqueId();
+ String parentReqUniqId = requirementId;
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource,
+ computeComponent, reqName1, false, capabilty1.getUniqueId(), requirementId);
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ log.debug(webGraph);
+
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(reqName2);
+
+ relationPair.setCapabilityUid(capabilty1.getUniqueId());
+ relationPair.setRequirementUid(requirementId);
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService1 = resourceInstanceOperation
+ .connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(),
+ resInstances.get(1).getUniqueId(), relationPair);
+ assertEquals("check cannot associate resource instances", TitanOperationStatus.ILLEGAL_ARGUMENT,
+ connectResourcesInService1.right().value());
+ relationPair.setRequirement(reqName1);
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService2 = resourceInstanceOperation
+ .connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(),
+ resInstances.get(1).getUniqueId(), relationPair);
+ assertEquals("check cannot associate resource instances", TitanOperationStatus.TITAN_SCHEMA_VIOLATION,
+ connectResourcesInService2.right().value());
+
+ relationPair.setRequirement(reqName1);
+
+ RequirementCapabilityRelDef capabilityRelDef = new RequirementCapabilityRelDef();
+ capabilityRelDef.setFromNode(resInstances.get(0).getUniqueId());
+ capabilityRelDef.setToNode(resInstances.get(1).getUniqueId());
+ List<RequirementAndRelationshipPair> list = new ArrayList<>();
+ list.add(relationPair);
+
+ disconnectResourcesInService(serviceName, capabilityRelDef);
+
+ } finally {
+ rollbackAndPrint();
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ private void rollbackAndPrint() {
+ rollbackAndPrint(false);
+ }
+
+ private void rollbackAndPrint(boolean print) {
+ TitanOperationStatus rollback = titanDao.rollback();
+ if (print) {
+ log.debug("rollback status={}", rollback);
+ PrintGraph printGraph = new PrintGraph();
+ printGraph.printGraphVertices(titanDao.getGraph().left().value());
+ }
+ }
+
+ @Test
+ public void testConnectResourceInstances2Requirement2Capabilities() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ try {
+
+ String capabilityTypeName1 = CAPABILITY_1;
+ String capabilityTypeName2 = CAPABILITY_2;
+ String reqName1 = "host1";
+ String reqName2 = "host2";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName1);
+ CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName2);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // rollbackAndPrint();
+ // OKKKKKKK
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ // rollbackAndPrint();
+ // OKKKKKKKKKK
+
+ // Add capabilities to Compute Resource
+ CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
+ CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
+
+ // rollbackAndPrint();
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource1 = addRequirementToResource(
+ capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource2 = addRequirementToResource(
+ capabilityTypeName2, reqName2, reqNodeName, reqRelationship, softwareComponent);
+
+ // create my resource derived from software component
+ String MY_RESOURCE = "my-resource";
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, MY_RESOURCE,
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ String requirementId1 = addRequirementToResource1.left().value().getUniqueId();
+ String requirementId2 = addRequirementToResource2.left().value().getUniqueId();
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource,
+ computeComponent, reqName1, false, capabilty1.getUniqueId(), requirementId1);
+
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(reqName2);
+ relationPair.setCapabilityUid(capabilty2.getUniqueId());
+ relationPair.setRequirementUid(requirementId2);
+ relationPair.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
+ relationPair.setRequirementOwnerId(resInstances.get(0).getUniqueId());
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService1 = resourceInstanceOperation
+ .connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(),
+ resInstances.get(1).getUniqueId(), relationPair);
+ assertTrue("check associate resource instances succeed " + reqName2, connectResourcesInService1.isLeft());
+
+ // rollbackAndPrint();
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ log.debug(webGraph);
+
+ RequirementCapabilityRelDef reqCapDef = new RequirementCapabilityRelDef();
+ reqCapDef.setFromNode(resInstances.get(0).getUniqueId());
+ reqCapDef.setToNode(resInstances.get(1).getUniqueId());
+
+ relationPair.setRequirement(reqName1);
+ relationPair.setCapabilityUid(capabilty1.getUniqueId());
+ relationPair.setRequirementUid(requirementId1);
+ RelationshipImpl relationship = new RelationshipImpl();
+ relationship.setType(reqName1);
+ relationPair.setRelationships(relationship);
+
+ List<RequirementAndRelationshipPair> list = new ArrayList<>();
+ list.add(relationPair);
+ reqCapDef.setRelationships(list);
+
+ disconnectResourcesInService(serviceName, reqCapDef);
+
+ reqCapDef.getRelationships().clear();
+
+ RequirementAndRelationshipPair relationPair1 = new RequirementAndRelationshipPair();
+ relationPair1.setRequirement(reqName2);
+ relationPair1.setCapabilityUid(capabilty2.getUniqueId());
+ relationPair1.setRequirementUid(requirementId2);
+ relationPair1.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
+ relationPair1.setRequirementOwnerId(resInstances.get(0).getUniqueId());
+ relationship.setType(reqName2);
+ relationPair1.setRelationships(relationship);
+ reqCapDef.getRelationships().add(relationPair1);
+
+ disconnectResourcesInService(serviceName, reqCapDef);
+
+ RequirementCapabilityRelDef relation = new RequirementCapabilityRelDef();
+ String fromResUid = resInstances.get(0).getUniqueId();
+ String toResUid = resInstances.get(1).getUniqueId();
+ relation.setFromNode(fromResUid);
+ relation.setToNode(toResUid);
+ List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
+ RequirementAndRelationshipPair immutablePair1 = new RequirementAndRelationshipPair(reqName1, null);
+ RequirementAndRelationshipPair immutablePair2 = new RequirementAndRelationshipPair(reqName2, null);
+ immutablePair1.setCapabilityUid(capabilty1.getUniqueId());
+ immutablePair1.setRequirementUid(addRequirementToResource1.left().value().getUniqueId());
+ immutablePair1.setRequirementOwnerId(resInstances.get(0).getUniqueId());
+ immutablePair1.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
+
+ immutablePair2.setCapabilityUid(capabilty2.getUniqueId());
+ immutablePair2.setRequirementUid(addRequirementToResource2.left().value().getUniqueId());
+ immutablePair2.setRequirementOwnerId(resInstances.get(0).getUniqueId());
+ immutablePair2.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
+
+ relationships.add(immutablePair1);
+ relationships.add(immutablePair2);
+ relation.setRelationships(relationships);
+
+ Either<RequirementCapabilityRelDef, StorageOperationStatus> associateResourceInstances = resourceInstanceOperation
+ .associateResourceInstances(serviceName, NodeTypeEnum.Service, relation, true);
+ assertTrue("check return code after associating 2 requirements in one request",
+ associateResourceInstances.isLeft());
+ RequirementCapabilityRelDef capabilityRelDef = associateResourceInstances.left().value();
+ String fromNode = capabilityRelDef.getFromNode();
+ assertEquals("check from node", resInstances.get(0).getUniqueId(), fromNode);
+ String toNode = capabilityRelDef.getToNode();
+ assertEquals("check to node", resInstances.get(1).getUniqueId(), toNode);
+ List<RequirementAndRelationshipPair> relationships2 = capabilityRelDef.getRelationships();
+ assertEquals("check number of relations", 2, relationships2.size());
+
+ for (RequirementAndRelationshipPair pair : relationships2) {
+ String key = pair.getRequirement();
+ RelationshipImpl relationshipImpl = pair.getRelationship();
+ if (key.equals(reqName1)) {
+ String type = relationshipImpl.getType();
+ assertEquals("Check relationship type name", reqRelationship, type);
+ } else if (key.equals(reqName2)) {
+ String type = relationshipImpl.getType();
+ assertEquals("Check relationship type name", reqRelationship, type);
+ } else {
+ assertTrue("requirement " + key + " was not found in the original request", false);
+ }
+ }
+
+ verifyGetAllResourceInstanceFromService(reqName1, reqName2, serviceName, fromResUid, toResUid);
+
+ List<ResourceMetadataData> resourcesPathList = new ArrayList<ResourceMetadataData>();
+ TitanOperationStatus findResourcesPathRecursively = resourceOperation
+ .findResourcesPathRecursively(resource.getUniqueId(), resourcesPathList);
+ assertEquals("check returned status", TitanOperationStatus.OK, findResourcesPathRecursively);
+ assertEquals("check list size", 3, resourcesPathList.size());
+
+ TitanOperationStatus validateTheTargetResourceInstance = resourceInstanceOperation
+ .validateTheTargetResourceInstance(MY_RESOURCE, resource.getUniqueId());
+ assertEquals("check resource name in the path", TitanOperationStatus.OK, validateTheTargetResourceInstance);
+ validateTheTargetResourceInstance = resourceInstanceOperation
+ .validateTheTargetResourceInstance(softwareCompName, resource.getUniqueId());
+ assertEquals("check resource name in the path", TitanOperationStatus.OK, validateTheTargetResourceInstance);
+
+ validateTheTargetResourceInstance = resourceInstanceOperation
+ .validateTheTargetResourceInstance(softwareCompName + "STAM", resource.getUniqueId());
+ assertEquals("check resource name not in the path", TitanOperationStatus.MATCH_NOT_FOUND,
+ validateTheTargetResourceInstance);
+
+ Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation
+ .deleteComponentInstance(NodeTypeEnum.Service, serviceName, toResUid, true);
+ assertTrue("check resource instance was deleted.", deleteResourceInstance.isLeft());
+
+ } finally {
+ rollbackAndPrint(false);
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ private void verifyGetAllResourceInstanceFromService(String reqName1, String reqName2, String serviceName,
+ String fromResUid, String toResUid) {
+
+ Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, StorageOperationStatus> allResourceInstances = resourceInstanceOperation
+ .getAllComponentInstances(serviceName, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
+ // assertTrue("check return code after get all resource instances",
+ // associateResourceInstances.isLeft());
+ ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>> immutablePair = allResourceInstances
+ .left().value();
+ List<ComponentInstance> nodes = immutablePair.getKey();
+ List<RequirementCapabilityRelDef> edges = immutablePair.getValue();
+ assertEquals("check 2 nodes returned", 2, nodes.size());
+ assertEquals("check one relation returned", 1, edges.size());
+ RequirementCapabilityRelDef requirementCapabilityRelDef = edges.get(0);
+ assertEquals("check from node", requirementCapabilityRelDef.getFromNode(), fromResUid);
+ requirementCapabilityRelDef.getToNode();
+ assertEquals("check to node", requirementCapabilityRelDef.getToNode(), toResUid);
+ int size = requirementCapabilityRelDef.getRelationships().size();
+ assertEquals("check number of relations", 2, size);
+ String req1 = requirementCapabilityRelDef.getRelationships().get(0).getRequirement();
+ String req2 = requirementCapabilityRelDef.getRelationships().get(1).getRequirement();
+
+ List<String> requirements = new ArrayList<String>();
+ requirements.add(req1);
+ requirements.add(req2);
+
+ assertTrue("check requirement returned " + reqName1, requirements.contains(reqName1));
+ assertTrue("check requirement returned " + reqName2, requirements.contains(reqName2));
+
+ String nodesStr = prettyGson.toJson(nodes);
+ String edgesStr = prettyGson.toJson(edges);
+
+ log.debug(nodesStr);
+ log.debug(edgesStr);
+ }
+
+ private Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource(String capabilityTypeName1,
+ String reqName1, String reqNodeName, String reqRelationship, Resource softwareComponent) {
+ RequirementDefinition reqDefinition1 = new RequirementDefinition();
+ reqDefinition1.setNode(reqNodeName);
+ reqDefinition1.setRelationship(reqRelationship);
+ reqDefinition1.setCapability(capabilityTypeName1);
+ // add requirement to software component
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation
+ .addRequirementToResource(reqName1, reqDefinition1, softwareComponent.getUniqueId(), true);
+ assertEquals("check requirement was added", true, addRequirementToResource.isLeft());
+ return addRequirementToResource;
+ }
+
+ private CapabilityDefinition addCapabilityToResource(String capabilityTypeName1, String reqName1,
+ Resource computeComponent) {
+ CapabilityDefinition capabilityDefinition1 = new CapabilityDefinition();
+ capabilityDefinition1.setDescription("my capability");
+ capabilityDefinition1.setType(capabilityTypeName1);
+ List<String> validSourceTypes = new ArrayList<String>();
+ validSourceTypes.add("tosca.nodes.SC");
+ capabilityDefinition1.setValidSourceTypes(validSourceTypes);
+ Either<CapabilityDefinition, StorageOperationStatus> addCapability = capabilityOperation
+ .addCapability(computeComponent.getUniqueId(), reqName1, capabilityDefinition1, true);
+ assertTrue("check capability created ", addCapability.isLeft());
+ return addCapability.left().value();
+ }
+
+ @Test
+ public void testConnectResourceInstancesCapabilityNameDiffFromReqName() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ try {
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ String DIFFERENT_CAPABILITY = "hostDiffernet";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ CapabilityDefinition capabilty = addCapabilityToResource(capabilityTypeName, DIFFERENT_CAPABILITY,
+ computeComponent);
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource,
+ computeComponent, "host", false, capabilty.getUniqueId(), parentReqUniqId);
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ // log.debug(webGraph);
+
+ } finally {
+ rollbackAndPrint();
+
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ @Test
+ public void testConnectResourceInstancesInvalidCapability() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ try {
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ String capabilityTypeNameOther = CAPABILITY_2 + "othertype";
+
+ String DIFFERENT_CAPABILITY = "hostDiffernet";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName);
+
+ CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeNameOther);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ addCapabilityToResource(capabilityTypeName, DIFFERENT_CAPABILITY, computeComponent);
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeNameOther, reqName, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstancesWithError(serviceName,
+ resource, computeComponent, "host", false, TitanOperationStatus.ILLEGAL_ARGUMENT);
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ log.debug(webGraph);
+
+ } finally {
+ rollbackAndPrint();
+
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ private void compareGraphSize(int numberOfVertices, Set<String> toRemoveFromSet) {
+ PrintGraph printGraph2 = new PrintGraph();
+ int numberOfVerticesCurr = printGraph2.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ Set<String> set = printGraph2.getVerticesSet(titanDao.getGraph().left().value());
+ if (toRemoveFromSet != null) {
+ set.removeAll(toRemoveFromSet);
+ }
+
+ assertEquals("check all data deleted from graph " + set, numberOfVertices, numberOfVerticesCurr);
+ }
+
+ private void compareGraphSize(int numberOfVertices) {
+ PrintGraph printGraph2 = new PrintGraph();
+ int numberOfVerticesCurr = printGraph2.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ assertEquals(
+ "check all data deleted from graph " + printGraph2.getVerticesSet(titanDao.getGraph().left().value()),
+ numberOfVertices, numberOfVerticesCurr);
+ }
+
+ @Test
+ public void testConnectResourceInstancesRequirementNotFound() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+ try {
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ String DIFFERENT_CAPABILITY = "hostDiffernet";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ addCapabilityToResource(capabilityTypeName, reqName, computeComponent);
+
+ // create requirement definition
+
+ RequirementDefinition reqDefinition = new RequirementDefinition();
+ reqDefinition.setNode(reqNodeName);
+ reqDefinition.setRelationship(reqRelationship);
+ reqDefinition.setCapability(capabilityTypeName);
+ // add requirement to software component
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation
+ .addRequirementToResource(reqName + "ssssssss", reqDefinition, softwareComponent.getUniqueId(),
+ true);
+ assertEquals("check requirement was added", true, addRequirementToResource.isLeft());
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceName = "myservice.1.0";
+ List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstancesWithError(serviceName,
+ resource, computeComponent, "host", false, TitanOperationStatus.ILLEGAL_ARGUMENT);
+
+ PrintGraph printGraph = new PrintGraph();
+ String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
+ log.debug(webGraph);
+
+ } finally {
+ titanDao.rollback();
+
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ private void disconnectResourcesInService(String serviceName, RequirementCapabilityRelDef reqCapDef) {
+
+ Either<List<RelationshipInstData>, TitanOperationStatus> disconnectResourcesInService = resourceInstanceOperation
+ .disconnectResourcesInService(serviceName, NodeTypeEnum.Service, reqCapDef);
+ assertTrue("check relatioship instance was deleted", disconnectResourcesInService.isLeft());
+
+ disconnectResourcesInService = resourceInstanceOperation.disconnectResourcesInService(serviceName,
+ NodeTypeEnum.Service, reqCapDef);
+ assertTrue("check relatioship instance already was deleted", disconnectResourcesInService.isRight());
+ assertEquals("check relatioship instance already was deleted. status NOT_FOUND", TitanOperationStatus.NOT_FOUND,
+ disconnectResourcesInService.right().value());
+ }
+
+ private List<ComponentInstance> buildServiceAndConnectBetweenResourceInstancesWithError(String serviceName,
+ Resource resource, Resource computeComponent, String requirement, boolean ignoreCreatingService,
+ TitanOperationStatus titanOperationStatus) {
+
+ String serviceId = "myservice.1.0";
+
+ if (false == ignoreCreatingService) {
+ ServiceMetadataData createService = createService(serviceId);
+ }
+ ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", resource.getName());
+
+ ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2",
+ computeComponent.getName());
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+ ComponentInstance value1 = myinstanceRes.left().value();
+ Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance,
+ NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", computeInstTes.isLeft());
+ ComponentInstance value2 = computeInstTes.left().value();
+
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(requirement);
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation
+ .connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(),
+ relationPair);
+
+ assertTrue("check relation was not created", connectResourcesInService.isRight());
+ assertEquals("check error code after connect resource instances failed", titanOperationStatus,
+ connectResourcesInService.right().value());
+
+ List<ComponentInstance> resInstances = new ArrayList<ComponentInstance>();
+ resInstances.add(value1);
+
+ return resInstances;
+
+ }
+
+ private List<ComponentInstance> buildServiceAndConnectBetweenResourceInstances(String serviceName,
+ Resource resource, Resource computeComponent, String requirement, boolean ignoreCreatingService,
+ String capabilityId, String requirementId) {
+
+ String serviceId = "myservice.1.0";
+
+ if (false == ignoreCreatingService) {
+ ServiceMetadataData createService = createService(serviceId);
+ }
+ ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", resource.getName());
+
+ ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2",
+ computeComponent.getName());
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+ ComponentInstance value1 = myinstanceRes.left().value();
+ Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance,
+ NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", computeInstTes.isLeft());
+ ComponentInstance value2 = computeInstTes.left().value();
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(requirement);
+
+ relationPair.setCapabilityUid(capabilityId);
+ relationPair.setRequirementUid(requirementId);
+ relationPair.setRequirementOwnerId(value1.getUniqueId());
+ relationPair.setCapabilityOwnerId(value2.getUniqueId());
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation
+ .connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(),
+ relationPair);
+
+ assertTrue("check relation created", connectResourcesInService.isLeft());
+
+ List<ComponentInstance> resInstances = new ArrayList<ComponentInstance>();
+ resInstances.add(value1);
+ resInstances.add(value2);
+
+ return resInstances;
+
+ }
+
+ @Test
+ public void getAllResourceInstancesThree() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+ try {
+
+ Set<String> vertexSetBeforeMethod = printGraph1.getVerticesSet(titanDao.getGraph().left().value());
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ // rollbackAndPrint();
+
+ // Add capabilities to Compute Resource
+ CapabilityDefinition capability = addCapabilityToResource(capabilityTypeName, "host", computeComponent);
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceId = "myservice.1.0";
+
+ ServiceMetadataData createService = createService(serviceId);
+
+ Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, StorageOperationStatus> allResourceInstances = resourceInstanceOperation
+ .getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
+ assertTrue("check NOT_FOUND is returned", allResourceInstances.isRight());
+ assertEquals("check NOT_FOUND is returned", allResourceInstances.right().value(),
+ StorageOperationStatus.NOT_FOUND);
+
+ ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", "my-resource");
+ myresourceInstance.setName("my-resource");
+
+ ComponentInstance computeInstance1 = buildResourceInstance(computeComponent.getUniqueId(), "2",
+ "tosca.nodes.Compute2");
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+ ComponentInstance value1 = myinstanceRes.left().value();
+
+ allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instances found", allResourceInstances.isLeft());
+ ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>> immutablePair = allResourceInstances
+ .left().value();
+ List<ComponentInstance> nodes = immutablePair.getKey();
+ List<RequirementCapabilityRelDef> edges = immutablePair.getValue();
+
+ assertEquals("check resource instances size", 1, nodes.size());
+ assertEquals("check resource instances size", 0, edges.size());
+
+ Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true,
+ computeInstance1, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", computeInstTes.isLeft());
+ ComponentInstance value2 = computeInstTes.left().value();
+
+ allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instances found", allResourceInstances.isLeft());
+ immutablePair = allResourceInstances.left().value();
+ nodes = immutablePair.getKey();
+ edges = immutablePair.getValue();
+
+ assertEquals("check resource instances size", 2, nodes.size());
+ assertEquals("check resource instances size", 0, edges.size());
+
+ String requirement = "host";
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(requirement);
+ relationPair.setCapabilityUid(capability.getUniqueId());
+ relationPair.setRequirementUid(addRequirementToResource.left().value().getUniqueId());
+ relationPair.setRequirementOwnerId(value1.getUniqueId());
+ relationPair.setCapabilityOwnerId(value2.getUniqueId());
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation
+ .connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(),
+ value2.getUniqueId(), relationPair);
+
+ assertTrue("check relation created", connectResourcesInService.isLeft());
+
+ allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instances found", allResourceInstances.isLeft());
+ immutablePair = allResourceInstances.left().value();
+ nodes = immutablePair.getKey();
+ edges = immutablePair.getValue();
+
+ assertEquals("check resource instances size", 2, nodes.size());
+ assertEquals("check resource instances size", 1, edges.size());
+
+ List<ComponentInstance> resInstances2 = new ArrayList<ComponentInstance>();
+ resInstances2.add(value1);
+ resInstances2.add(value2);
+
+ ComponentInstance myresourceInstance2 = buildResourceInstance(resource.getUniqueId(), "1", "myresource2");
+
+ Either<ComponentInstance, TitanOperationStatus> newResource = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "3", true,
+ myresourceInstance2, NodeTypeEnum.Resource, false);
+
+ assertTrue("added resource instance successfully", newResource.isLeft());
+
+ relationPair.setRequirement(requirement);
+ relationPair.setRequirementOwnerId(newResource.left().value().getUniqueId());
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService2 = resourceInstanceOperation
+ .connectResourcesInService(serviceId, NodeTypeEnum.Service,
+ newResource.left().value().getUniqueId(), value2.getUniqueId(), relationPair);
+ assertTrue("check resource instance was added to service", connectResourcesInService2.isLeft());
+
+ allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instances found", allResourceInstances.isLeft());
+ immutablePair = allResourceInstances.left().value();
+ nodes = immutablePair.getKey();
+ edges = immutablePair.getValue();
+
+ assertEquals("check resource instances size", 3, nodes.size());
+ assertEquals("check resource instances size", 2, edges.size());
+
+ Either<List<ComponentInstance>, TitanOperationStatus> deleteAllResourceInstancesOfService = resourceInstanceOperation
+ .deleteAllComponentInstancesInternal(serviceId, NodeTypeEnum.Service);
+ assertTrue("check resource instances was deleted.", deleteAllResourceInstancesOfService.isLeft());
+ assertEquals("check number of deleted resource instances.", 3,
+ deleteAllResourceInstancesOfService.left().value().size());
+
+ Either<List<RelationshipInstData>, TitanOperationStatus> allRelatinshipInst = titanDao
+ .getAll(NodeTypeEnum.RelationshipInst, RelationshipInstData.class);
+ assertTrue("allRelatinshipInst is empty", allRelatinshipInst.isRight());
+ assertEquals("allRelatinshipInst result is NOT_FOUND", TitanOperationStatus.NOT_FOUND,
+ allRelatinshipInst.right().value());
+
+ Either<Resource, StorageOperationStatus> deleteComputeResource = resourceOperation
+ .deleteResource(computeComponent.getUniqueId(), true);
+ assertTrue("delete compute resource succeed", deleteComputeResource.isLeft());
+
+ Either<Resource, StorageOperationStatus> deleteSCResource = resourceOperation
+ .deleteResource(softwareComponent.getUniqueId(), true);
+ assertTrue("delete software component resource succeed", deleteSCResource.isLeft());
+
+ Either<Resource, StorageOperationStatus> deleteMyResource = resourceOperation
+ .deleteResource(resource.getUniqueId(), true);
+ assertTrue("delete my resource succeed", deleteMyResource.isLeft());
+
+ Either<Resource, StorageOperationStatus> rootResourceDeleted = resourceOperation
+ .deleteResource(rootResource.getUniqueId(), true);
+ assertTrue("delete root resource succeed", rootResourceDeleted.isLeft());
+
+ Set<String> vertexSetAfterDelete = printGraph1.getVerticesSet(titanDao.getGraph().left().value());
+
+ vertexSetAfterDelete.removeAll(vertexSetBeforeMethod);
+
+ log.debug("vertexSetAfterDelete={}", vertexSetAfterDelete);
+ log.debug("vertexSetAfterDelete size={}", vertexSetAfterDelete.size());
+
+ // int numberOfVerticesAfterOperation =
+ // printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+ // System.out.println(numberOfVerticesAfterOperation);
+ // 6 - service, 2 tags, capability + 2 parameters
+ // compareGraphSize(numberOfVertices + 6, vertexSetBeforeMethod);
+
+ } finally {
+ rollbackAndPrint(false);
+ compareGraphSize(numberOfVertices);
+ // printGraph1.printGraphVertices(titanDao.getGraph().left().value());
+ }
+
+ }
+
+ public void testCreateRootResource() {
+
+ String name = "tosca.nodes.Root";
+
+ String state = LifecycleStateEnum.CERTIFIED.name();
+
+ ResourceMetadataData resourceData1 = new ResourceMetadataData();
+ resourceData1.getMetadataDataDefinition().setUniqueId(UniqueIdBuilder.buildResourceUniqueId());
+ resourceData1.getMetadataDataDefinition().setName(name);
+ resourceData1.getMetadataDataDefinition().setState(state);
+ resourceData1.getMetadataDataDefinition().setHighestVersion(true);
+ resourceData1.getMetadataDataDefinition().setContactId("contactId");
+ Either<ResourceMetadataData, TitanOperationStatus> createNode1 = titanDao.createNode(resourceData1,
+ ResourceMetadataData.class);
+
+ log.debug("{}", createNode1);
+
+ titanDao.commit();
+ }
+
+ public void testMultiResourceCertified() {
+ boolean create = true;
+ String name = "myresource7";
+ if (create) {
+
+ String state = LifecycleStateEnum.CERTIFIED.name();
+ boolean isHighestVersion = true;
+
+ ResourceMetadataData resourceData1 = new ResourceMetadataData();
+ resourceData1.getMetadataDataDefinition().setUniqueId(name + "." + "1.0");
+ resourceData1.getMetadataDataDefinition().setName(name);
+ resourceData1.getMetadataDataDefinition().setState(state);
+ resourceData1.getMetadataDataDefinition().setHighestVersion(true);
+ resourceData1.getMetadataDataDefinition().setContactId("contactId");
+ Either<ResourceMetadataData, TitanOperationStatus> createNode1 = titanDao.createNode(resourceData1,
+ ResourceMetadataData.class);
+
+ log.debug("{}", createNode1);
+
+ titanDao.commit();
+
+ // resourceData1.setHighestVersion(false);
+ resourceData1.getMetadataDataDefinition().setContactId("222contactId222");
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData1,
+ ResourceMetadataData.class);
+
+ titanDao.commit();
+
+ // TitanGraph titanGraph = titanDao.getGraph().left().value();
+ // Iterable<Result<Vertex>> vertices =
+ // titanGraph.indexQuery("highestVersion",
+ // "v.highestVersion:true").vertices();
+ // for (Result<Vertex> vertex : vertices) {
+ // Vertex element = vertex.getElement();
+ // System.out.println( ElementHelper.getProperties(element));
+ // }
+
+ }
+
+ Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = searchForResource(name);
+
+ log.debug("{}", byCriteria.left().value().size());
+
+ byCriteria = searchForResource(name);
+
+ log.debug("{}", byCriteria.left().value().size());
+
+ }
+
+ private Either<List<ResourceMetadataData>, TitanOperationStatus> searchForResource(String name) {
+ Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
+ propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
+ // propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(),
+ // true);
+ propertiesToMatch.put(GraphPropertiesDictionary.NAME.getProperty(), name);
+ propertiesToMatch.put(GraphPropertiesDictionary.CONTACT_ID.getProperty(), "contactId");
+ // propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(),
+ // true);
+ Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao
+ .getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
+ return byCriteria;
+ }
+
+ @Test
+ public void testCreateResourceInstanceTwice() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+ try {
+
+ String capabilityTypeName = CAPABILITY_2;
+ String reqName = "host";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ ComponentInstance myresourceInstance = buildResourceInstance(softwareComponent.getUniqueId(), "1",
+ softwareCompName);
+
+ String serviceName = "myservice.1.0";
+ ServiceMetadataData createService = createService(serviceName);
+ Either<ComponentInstance, StorageOperationStatus> myinstanceRes1 = resourceInstanceOperation
+ .createComponentInstance(serviceName, NodeTypeEnum.Service, "1", myresourceInstance,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instance was created", myinstanceRes1.isLeft());
+
+ Either<ComponentInstance, StorageOperationStatus> myinstanceRes2 = resourceInstanceOperation
+ .createComponentInstance(serviceName, NodeTypeEnum.Service, "1", myresourceInstance,
+ NodeTypeEnum.Resource, true);
+ assertTrue("check resource instance was not created", myinstanceRes2.isRight());
+ assertEquals("check error code", StorageOperationStatus.SCHEMA_VIOLATION, myinstanceRes2.right().value());
+
+ Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation
+ .deleteComponentInstance(NodeTypeEnum.Service, serviceName,
+ myinstanceRes1.left().value().getUniqueId(), true);
+ assertTrue("check resource instance was deleted", deleteResourceInstance.isLeft());
+
+ deleteResourceInstance = resourceInstanceOperation.deleteComponentInstance(NodeTypeEnum.Service,
+ serviceName, myinstanceRes1.left().value().getUniqueId(), true);
+ assertTrue("check resource instance was not deleted", deleteResourceInstance.isRight());
+ assertEquals("check resource instance was not deleted", StorageOperationStatus.NOT_FOUND,
+ deleteResourceInstance.right().value());
+
+ } finally {
+ rollbackAndPrint(false);
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ @Test
+ public void testConnectResourceInstancesTwice() {
+
+ PrintGraph printGraph1 = new PrintGraph();
+ int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
+
+ try {
+
+ String capabilityTypeName1 = CAPABILITY_1;
+ String capabilityTypeName2 = CAPABILITY_2;
+ String reqName1 = "host1";
+ String reqName2 = "host2";
+ String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
+ String rootName = "Root2" + TEST_CLASS_NUMBER;
+ String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
+ String computeNodeName = reqNodeName;
+ String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
+ String reqRelationship = "myrelationship";
+
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName1);
+ CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest
+ .createCapability(capabilityTypeName2);
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ // create root resource
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null,
+ true, true);
+
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+
+ // create software component
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ // create compute component
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName,
+ "1.0", rootResource.getName(), true, true);
+
+ // Add capabilities to Compute Resource
+ CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
+ CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
+
+ // rollbackAndPrint();
+
+ // create requirement definition
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ // create my resource derived from software component
+ Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource",
+ myResourceVersion, softwareComponent.getName(), true, true);
+
+ String serviceId = "myservice.1.0";
+
+ ServiceMetadataData createService = createService(serviceId);
+ ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", "my-resource");
+
+ ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2",
+ computeNodeName);
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+ ComponentInstance value1 = myinstanceRes.left().value();
+ Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true,
+ computeInstance, NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", computeInstTes.isLeft());
+ ComponentInstance value2 = computeInstTes.left().value();
+
+ RequirementCapabilityRelDef relation = new RequirementCapabilityRelDef();
+ String fromResUid = value1.getUniqueId();
+ String toResUid = value2.getUniqueId();
+ relation.setFromNode(fromResUid);
+ relation.setToNode(toResUid);
+ List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
+ RequirementAndRelationshipPair immutablePair1 = new RequirementAndRelationshipPair(reqName1, null);
+ immutablePair1.setCapabilityUid(capabilty1.getUniqueId());
+ immutablePair1.setRequirementUid(parentReqUniqId);
+ immutablePair1.setRequirementOwnerId(fromResUid);
+ immutablePair1.setCapabilityOwnerId(toResUid);
+ relationships.add(immutablePair1);
+
+ relation.setRelationships(relationships);
+
+ Either<RequirementCapabilityRelDef, StorageOperationStatus> connectResourcesInService = resourceInstanceOperation
+ .associateResourceInstances(serviceId, NodeTypeEnum.Service, relation, true);
+ assertTrue("check association succeed", connectResourcesInService.isLeft());
+
+ relationships.clear();
+ RequirementAndRelationshipPair immutablePair2 = new RequirementAndRelationshipPair(reqName2, null);
+ immutablePair2.setCapabilityUid(capabilty2.getUniqueId());
+ immutablePair2.setRequirementUid(parentReqUniqId);
+ relationships.add(immutablePair2);
+
+ RequirementCapabilityRelDef firstRelation = connectResourcesInService.left().value();
+ connectResourcesInService = resourceInstanceOperation.associateResourceInstances(serviceId,
+ NodeTypeEnum.Service, relation, true);
+ assertTrue("check association succeed", connectResourcesInService.isRight());
+ assertEquals("check association failed", StorageOperationStatus.MATCH_NOT_FOUND,
+ connectResourcesInService.right().value());
+
+ Either<RequirementCapabilityRelDef, StorageOperationStatus> disconnectResourcesInService = resourceInstanceOperation
+ .dissociateResourceInstances(serviceId, NodeTypeEnum.Service, firstRelation, true);
+
+ assertTrue("check dissociation succeed", disconnectResourcesInService.isLeft());
+
+ disconnectResourcesInService = resourceInstanceOperation.dissociateResourceInstances(serviceId,
+ NodeTypeEnum.Service, relation, true);
+
+ assertTrue("check dissociation failed", disconnectResourcesInService.isRight());
+ assertEquals("check association failed", StorageOperationStatus.NOT_FOUND,
+ disconnectResourcesInService.right().value());
+ } finally {
+ rollbackAndPrint();
+ compareGraphSize(numberOfVertices);
+ }
+
+ }
+
+ private Resource createComputeWithCapability(String capabilityTypeName, String computeNodeName,
+ ResourceOperationTest resourceOperationTest, Resource rootResource) {
+ // create compute component
+ // String id = UniqueIdBuilder.buildResourceUniqueId(computeNodeName,
+ // "1.0");
+ // if (resourceOperation.getResource(id).isLeft()){
+ // resourceOperation.deleteResource(id);
+ // }
+ Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation
+ .getResourceByNameAndVersion(computeNodeName, "1.0", false);
+ if (oldResource.isLeft()) {
+ for (Resource old : oldResource.left().value()) {
+ if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
+ resourceOperation.deleteResource(old.getUniqueId());
+ }
+ }
+
+ }
+
+ Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0",
+ rootResource.getName(), true, true);
+
+ // rollbackAndPrint();
+
+ // Add capabilities to Compute Resource
+ addCapabilityToResource(capabilityTypeName, "host", computeComponent);
+ return resourceOperation.getResource(computeComponent.getUniqueId()).left().value();
+ }
+
+ private Resource createSoftwareComponentWithReq(String softwareCompName,
+ ResourceOperationTest resourceOperationTest, Resource rootResource, String capabilityTypeName,
+ String reqName, String reqRelationship, String reqNodeName) {
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode;
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ // create software component
+ // String id = UniqueIdBuilder.buildResourceUniqueId(softwareCompName,
+ // "1.0");
+ // if (resourceOperation.getResource(id).isLeft()){
+ // resourceOperation.deleteResource(id);
+ // }
+ Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation
+ .getResourceByNameAndVersion(softwareCompName, "1.0", false);
+ if (oldResource.isLeft()) {
+ if (oldResource.isLeft()) {
+ for (Resource old : oldResource.left().value()) {
+ if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
+ resourceOperation.deleteResource(old.getUniqueId());
+ }
+ }
+
+ }
+ }
+
+ Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName,
+ "1.0", rootResource.getName(), true, true);
+
+ resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(
+ capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
+
+ String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
+
+ return resourceOperation.getResource(softwareComponent.getUniqueId()).left().value();
+ }
+
+ private Resource createRootResource(String rootName, ResourceOperationTest resourceOperationTest) {
+ // create root resource
+ // String rootId = UniqueIdBuilder.buildResourceUniqueId(rootName,
+ // "1.0");
+ Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation
+ .getResourceByNameAndVersion(rootName, "1.0", false);
+ if (oldResource.isLeft()) {
+ for (Resource old : oldResource.left().value()) {
+ if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
+ resourceOperation.deleteResource(old.getUniqueId());
+ }
+ }
+
+ }
+ Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true,
+ true);
+ ResourceMetadataData rootResourceData = new ResourceMetadataData();
+ rootResourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
+ rootResourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(rootResourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation
+ .getResource(rootResource.getUniqueId(), true);
+
+ String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
+ log.debug(rootResourceJson);
+ return rootResource;
+ }
+
+ public void addResourceInstancesAndRelation(String serviceId) {
+
+ String rootName = "tosca.nodes.test.root";
+ String softwareCompName = "tosca.nodes.test.softwarecomponent";
+ String capabilityTypeName = "myCapability";
+ String reqName = "host";
+ String computeNodeName = "tosca.nodes.test.compute";
+ String reqRelationship = "myRelationship";
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = createRootResource(rootName, resourceOperationTest);
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
+
+ Resource softwareComponentResource = createSoftwareComponentWithReq(softwareCompName, resourceOperationTest,
+ rootResource, capabilityTypeName, reqName, reqRelationship, computeNodeName);
+ Resource compute = createComputeWithCapability(capabilityTypeName, computeNodeName, resourceOperationTest,
+ rootResource);
+
+ // resource1
+ ComponentInstance myresourceInstance = buildResourceInstance(softwareComponentResource.getUniqueId(), "1",
+ "tosca.nodes.test.root");
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+
+ // resource2
+ ComponentInstance computeInstance = buildResourceInstance(compute.getUniqueId(), "2",
+ "tosca.nodes.test.compute");
+ ComponentInstance value1 = myinstanceRes.left().value();
+
+ Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance,
+ NodeTypeEnum.Resource, false);
+ assertTrue("check instance added to service", computeInstTes.isLeft());
+ ComponentInstance value2 = computeInstTes.left().value();
+
+ RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
+ relationPair.setRequirement(reqName);
+ relationPair.setCapability(capabilityTypeName);
+
+ String capId = "";
+ Map<String, List<CapabilityDefinition>> capabilities = compute.getCapabilities();
+ for (Map.Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {
+ capId = entry.getValue().get(0).getUniqueId();
+ }
+ relationPair.setCapabilityUid(capId);
+ Map<String, List<RequirementDefinition>> requirements = softwareComponentResource.getRequirements();
+ String reqId = "";
+ for (Map.Entry<String, List<RequirementDefinition>> entry : requirements.entrySet()) {
+ reqId = entry.getValue().get(0).getUniqueId();
+ }
+ relationPair.setRequirementUid(reqId);
+ relationPair.setRequirementOwnerId(value1.getUniqueId());
+ relationPair.setCapabilityOwnerId(value2.getUniqueId());
+ relationPair.setCapabilityUid(capId);
+
+ Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation
+ .connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(),
+ relationPair);
+
+ assertTrue("check relation created", connectResourcesInService.isLeft());
+
+ }
+
+ @Test
+ public void addResourceInstancesResourceDeleted() {
+
+ String rootName = "tosca.nodes.test.root";
+ String softwareCompName = "tosca.nodes.test.softwarecomponent";
+ String capabilityTypeName = "myCapability";
+ String reqName = "host";
+ String computeNodeName = "tosca.nodes.test.compute";
+ String reqRelationship = "myRelationship";
+
+ ServiceMetadataData origService = createService("myService");
+ String serviceId = (String) origService.getUniqueId();
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = createRootResource(rootName, resourceOperationTest);
+ // Create Capability type
+ CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
+ capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
+ capabilityTypeOperationTest.createCapability(capabilityTypeName);
+
+ Resource softwareComponentResource = createSoftwareComponentWithReq(softwareCompName, resourceOperationTest,
+ rootResource, capabilityTypeName, reqName, reqRelationship, computeNodeName);
+
+ deleteResource(softwareComponentResource.getUniqueId());
+
+ // resource1
+ ComponentInstance myresourceInstance = buildResourceInstance(softwareComponentResource.getUniqueId(), "1",
+ "tosca.nodes.test.root");
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+
+ assertTrue("check instance not added to service", myinstanceRes.isRight());
+
+ }
+
+ @Test
+ public void testDeploymentArtifactsOnRI() {
+
+ String rootName = "tosca.nodes.test.root";
+
+ ServiceMetadataData origService = createService("testDeploymentArtifactsOnRI");
+ String serviceId = (String) origService.getUniqueId();
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = createRootResource(rootName, resourceOperationTest);
+ ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(),
+ "myArtifact");
+
+ // resource1
+ ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+
+ Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation
+ .getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
+ assertTrue(resourceInstancesOfService.isLeft());
+ List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
+ assertTrue(resourceInstanceList.size() == 1);
+ ComponentInstance resourceInstance = resourceInstanceList.get(0);
+ assertTrue(resourceInstance.getDeploymentArtifacts().size() == 1);
+ Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
+ assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
+
+ ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
+ heatEnvArtifact.setArtifactType("HEAT_ENV");
+ heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
+ heatEnvArtifact.setUniqueId(null);
+
+ Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(
+ heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance,
+ false);
+ assertTrue(either.isLeft());
+
+ resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId,
+ NodeTypeEnum.Service, NodeTypeEnum.Resource);
+ assertTrue(resourceInstancesOfService.isLeft());
+ resourceInstanceList = resourceInstancesOfService.left().value().left;
+ assertTrue(resourceInstanceList.size() == 1);
+ resourceInstance = resourceInstanceList.get(0);
+ assertTrue(resourceInstance.getDeploymentArtifacts().size() == 2);
+ artifacts = resourceInstance.getDeploymentArtifacts();
+ assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
+ assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel() + "env"));
+ ArtifactDefinition heatEnvFromRI = artifacts.get(addArtifactToResource.getArtifactLabel() + "env");
+ assertEquals(addArtifactToResource.getUniqueId(), heatEnvFromRI.getGeneratedFromId());
+
+ List<HeatParameterDefinition> heatParameters = artifacts.get(addArtifactToResource.getArtifactLabel())
+ .getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+
+ List<HeatParameterDefinition> heatEnvParameters = heatEnvFromRI.getHeatParameters();
+ assertNotNull(heatEnvParameters);
+ assertTrue(heatEnvParameters.size() == 1);
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+
+ }
+
+ @Test
+ public void deleteResourceInstanceWithArtifacts() {
+ String rootName = "tosca.nodes.test.root";
+
+ ServiceMetadataData origService = createService("deleteResourceInstanceWithArtifacts");
+ String serviceId = (String) origService.getUniqueId();
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = createRootResource(rootName, resourceOperationTest);
+ ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(),
+ "myArtifact");
+
+ // resource1
+ ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+
+ ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
+ heatEnvArtifact.setArtifactType("HEAT_ENV");
+ heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
+ heatEnvArtifact.setUniqueId(null);
+
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+
+ Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation
+ .getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
+ assertTrue(resourceInstancesOfService.isLeft());
+ List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
+ assertTrue(resourceInstanceList.size() == 1);
+ ComponentInstance resourceInstance = resourceInstanceList.get(0);
+
+ Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(
+ heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance,
+ false);
+ assertTrue(either.isLeft());
+ ArtifactDefinition heatEnvDefinition = either.left().value();
+
+ // delete resource instance
+ Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation
+ .deleteComponentInstance(NodeTypeEnum.Service, serviceId, resourceInstance.getUniqueId());
+ assertTrue(deleteResourceInstance.isLeft());
+
+ // check heat env deleted
+ ArtifactData artifactData = new ArtifactData();
+ Either<ArtifactData, TitanOperationStatus> getDeletedArtifact = titanDao.getNode(artifactData.getUniqueIdKey(),
+ heatEnvDefinition.getUniqueId(), ArtifactData.class);
+ assertTrue(getDeletedArtifact.isRight());
+
+ // check heat is not deleted
+ getDeletedArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), addArtifactToResource.getUniqueId(),
+ ArtifactData.class);
+ assertTrue(getDeletedArtifact.isLeft());
+
+ HeatParameterData heatParamData = new HeatParameterData();
+ Either<HeatParameterData, TitanOperationStatus> heatParamNode = titanDao.getNode(heatParamData.getUniqueIdKey(),
+ addArtifactToResource.getHeatParameters().get(0).getUniqueId(), HeatParameterData.class);
+ assertTrue(heatParamNode.isLeft());
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+
+ }
+
+ @Test
+ public void getHeatEnvParams() {
+ String rootName = "tosca.nodes.test.root";
+
+ ServiceMetadataData origService = createService("getHeatEnvParams");
+ String serviceId = (String) origService.getUniqueId();
+
+ ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
+ resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
+
+ Resource rootResource = createRootResource(rootName, resourceOperationTest);
+ ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(),
+ "myArtifact");
+
+ // resource1
+ ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
+
+ Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation
+ .addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true,
+ myresourceInstance, NodeTypeEnum.Resource, false);
+
+ ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
+ heatEnvArtifact.setArtifactType("HEAT_ENV");
+ heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
+ heatEnvArtifact.setUniqueId(null);
+
+ assertTrue("check instance added to service", myinstanceRes.isLeft());
+
+ Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation
+ .getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
+ assertTrue(resourceInstancesOfService.isLeft());
+ List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
+ assertTrue(resourceInstanceList.size() == 1);
+ ComponentInstance resourceInstance = resourceInstanceList.get(0);
+
+ Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(
+ heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance,
+ false);
+ assertTrue(either.isLeft());
+ ArtifactDefinition heatEnvDefinition = either.left().value();
+
+ // update value
+ String newHeatValue = "123";
+ addHeatValueToEnv(heatEnvDefinition.getUniqueId(), addArtifactToResource.getHeatParameters().get(0),
+ newHeatValue);
+
+ // check values received
+
+ resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId,
+ NodeTypeEnum.Service, NodeTypeEnum.Resource);
+ assertTrue(resourceInstancesOfService.isLeft());
+ resourceInstanceList = resourceInstancesOfService.left().value().left;
+ assertTrue(resourceInstanceList.size() == 1);
+ resourceInstance = resourceInstanceList.get(0);
+ assertTrue(resourceInstance.getDeploymentArtifacts().size() == 2);
+ Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
+ assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
+ assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel() + "env"));
+
+ List<HeatParameterDefinition> heatParameters = artifacts.get(addArtifactToResource.getArtifactLabel())
+ .getHeatParameters();
+ assertNotNull(heatParameters);
+ assertTrue(heatParameters.size() == 1);
+ HeatParameterDefinition heatParameterTemplate = heatParameters.get(0);
+
+ List<HeatParameterDefinition> heatEnvParameters = artifacts
+ .get(addArtifactToResource.getArtifactLabel() + "env").getHeatParameters();
+ assertNotNull(heatEnvParameters);
+ assertTrue(heatEnvParameters.size() == 1);
+ HeatParameterDefinition heatParameterEnv = heatEnvParameters.get(0);
+
+ assertEquals(heatParameterEnv.getDefaultValue(), heatParameterTemplate.getCurrentValue());
+ assertEquals(newHeatValue, heatParameterEnv.getCurrentValue());
+ assertFalse(newHeatValue.equals(heatParameterTemplate.getCurrentValue()));
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+
+ }
+
+ public void addHeatValueToEnv(String artifactId, HeatParameterDefinition heatDefinition, String value) {
+ HeatParameterValueData heatValueData = new HeatParameterValueData();
+ heatValueData.setValue(value);
+ heatValueData.setUniqueId(artifactId + "." + heatDefinition.getName());
+ Either<HeatParameterValueData, TitanOperationStatus> createValue = titanDao.createNode(heatValueData,
+ HeatParameterValueData.class);
+ assertTrue(createValue.isLeft());
+ HeatParameterValueData value2 = createValue.left().value();
+ HeatParameterData heatParamData = new HeatParameterData(heatDefinition);
+ Either<GraphRelation, TitanOperationStatus> createRelation = titanDao.createRelation(value2, heatParamData,
+ GraphEdgeLabels.PROPERTY_IMPL, null);
+ assertTrue(createRelation.isLeft());
+ Map<String, Object> props = new HashMap<String, Object>();
+ props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), heatDefinition.getName());
+ Either<GraphRelation, TitanOperationStatus> createRelation2 = titanDao.createRelation(
+ new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId), value2, GraphEdgeLabels.PARAMETER_VALUE, props);
+ assertTrue(createRelation2.isLeft());
+ titanDao.commit();
+
+ }
+
+ public static String normaliseComponentName(String name) {
+ String[] split = splitComponentName(name);
+ StringBuffer sb = new StringBuffer();
+ for (String splitElement : split) {
+ sb.append(splitElement);
+ }
+ return sb.toString();
+
+ }
+
+ private static String[] splitComponentName(String name) {
+ String normalizedName = name.toLowerCase();
+ normalizedName = COMPONENT_NAME_DELIMETER_PATTERN.matcher(normalizedName).replaceAll(" ");
+ String[] split = normalizedName.split(" ");
+ return split;
+ }
+
+ public static String normaliseComponentInstanceName(String name) {
+ String[] split = splitComponentInstanceName(name);
+ StringBuffer sb = new StringBuffer();
+ for (String splitElement : split) {
+ sb.append(splitElement);
+ }
+ return sb.toString();
+
+ }
+
+ private static String[] splitComponentInstanceName(String name) {
+ String normalizedName = name.toLowerCase();
+ normalizedName = COMPONENT_INCTANCE_NAME_DELIMETER_PATTERN.matcher(normalizedName).replaceAll(" ");
+ String[] split = normalizedName.split(" ");
+ return split;
+ }
+
+ private ArtifactDefinition addArtifactToResource(String userId, String resourceId, String artifactName) {
+ ArtifactDefinition artifactInfo = new ArtifactDefinition();
+
+ artifactInfo.setArtifactName(artifactName + ".yml");
+ artifactInfo.setArtifactType("HEAT");
+ artifactInfo.setDescription("hdkfhskdfgh");
+ artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
+ artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+
+ artifactInfo.setUserIdCreator(userId);
+ String fullName = "Jim H";
+ artifactInfo.setUpdaterFullName(fullName);
+ long time = System.currentTimeMillis();
+ artifactInfo.setCreatorFullName(fullName);
+ artifactInfo.setCreationDate(time);
+ artifactInfo.setLastUpdateDate(time);
+ artifactInfo.setUserIdLastUpdater(userId);
+ artifactInfo.setArtifactLabel(artifactName);
+ artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, artifactInfo.getArtifactLabel()));
+ artifactInfo.setEsId(artifactInfo.getUniqueId());
+
+ List<HeatParameterDefinition> heatParams = new ArrayList<HeatParameterDefinition>();
+ HeatParameterDefinition heatParam = new HeatParameterDefinition();
+ heatParam.setCurrentValue("11");
+ heatParam.setDefaultValue("22");
+ heatParam.setDescription("desc");
+ heatParam.setName("myParam");
+ heatParam.setType("number");
+ heatParams.add(heatParam);
+ artifactInfo.setHeatParameters(heatParams);
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation
+ .addArifactToComponent(artifactInfo, resourceId, NodeTypeEnum.Resource, true, true);
+ assertTrue(artifact.isLeft());
+ return artifact.left().value();
+ }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperationTest.java
new file mode 100644
index 0000000000..f977509f6b
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperationTest.java
@@ -0,0 +1,734 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+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.GraphEdge;
+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.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.LifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
+import org.openecomp.sdc.be.resources.data.PropertyData;
+import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ResourceOperationTest extends ModelTestBase {
+
+ private static Logger log = LoggerFactory.getLogger(ResourceOperationTest.class.getName());
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "lifecycle-operation")
+ private LifecycleOperation lifecycleOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ private static String CATEGORY_NAME = "category/mycategory";
+ private static String CATEGORY_NAME_UPDATED = "category1/updatedcategory";
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+
+ ModelTestBase.init();
+ }
+
+ public void setOperations(TitanGenericDao titanGenericDao, ResourceOperation resourceOperation,
+ PropertyOperation propertyOperation) {
+ this.titanDao = titanGenericDao;
+ this.resourceOperation = resourceOperation;
+ this.propertyOperation = propertyOperation;
+ }
+
+ @Test
+ public void dummyTest() {
+
+ }
+
+ private Resource buildResourceMetadata(String userId, String category, String resourceName,
+ String resourceVersion) {
+
+ Resource resource = new Resource();
+ resource.setName(resourceName);
+ resource.setVersion(resourceVersion);
+ ;
+ resource.setDescription("description 1");
+ resource.setAbstract(false);
+ resource.setCreatorUserId(userId);
+ resource.setContactId("contactId@sdc.com");
+ resource.setVendorName("vendor 1");
+ resource.setVendorRelease("1.0.0");
+ resource.setToscaResourceName(resourceName);
+ String[] categoryArr = category.split("/");
+ resource.addCategory(categoryArr[0], categoryArr[1]);
+ resource.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ resource.setTags(tags);
+ return resource;
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+ }
+
+ public Resource createResource(String userId, String category, String resourceName, String resourceVersion,
+ String parentResourceName, boolean isAbstract, boolean isHighestVersion) {
+
+ String propName1 = "disk_size";
+ String propName2 = "num_cpus";
+
+ List<String> derivedFrom = new ArrayList<String>();
+ if (parentResourceName != null) {
+ derivedFrom.add(parentResourceName);
+ }
+ Resource resource = buildResourceMetadata(userId, category, resourceName, resourceVersion);
+
+ resource.setAbstract(isAbstract);
+ resource.setHighestVersion(isHighestVersion);
+
+ Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
+
+ PropertyDefinition property1 = new PropertyDefinition();
+ property1.setDefaultValue("10");
+ property1.setDescription(
+ "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
+ property1.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
+ GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
+ log.debug("{}", propertyConstraint1);
+
+ constraints.add(propertyConstraint1);
+
+ LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
+ constraints.add(propertyConstraint2);
+
+ property1.setConstraints(constraints);
+
+ properties.put(propName1, property1);
+
+ PropertyDefinition property2 = new PropertyDefinition();
+ property2.setDefaultValue("2");
+ property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
+ property2.setType(ToscaType.INTEGER.name().toLowerCase());
+ List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
+ List<String> range = new ArrayList<String>();
+ range.add("1");
+ range.add("4");
+
+ InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
+ constraints3.add(propertyConstraint3);
+ // property2.setConstraints(constraints3);
+ property2.setConstraints(constraints3);
+ properties.put(propName2, property2);
+
+ resource.setDerivedFrom(derivedFrom);
+
+ resource.setProperties(convertMapToList(properties));
+
+ Either<Resource, StorageOperationStatus> result = resourceOperation.createResource(resource, true);
+
+ assertTrue(result.isLeft());
+ Resource resultResource = result.left().value();
+
+ // assertEquals("check resource unique id",
+ // UniqueIdBuilder.buildResourceUniqueId(resourceName,
+ // resourceVersion), resultResource.getUniqueId());
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultResource.getLifecycleState());
+
+ // retrieve property from graph
+ String resourceId = resultResource.getUniqueId();
+ // String resourceId = UniqueIdBuilder.buildResourceUniqueId(
+ // resource.getResourceName(), resource.getResourceVersion());
+
+ Either<PropertyDefinition, StorageOperationStatus> either = propertyOperation.getPropertyOfResource(propName1,
+ resourceId);
+
+ assertTrue(either.isLeft());
+ PropertyDefinition propertyDefinition = either.left().value();
+ assertEquals("check property default value", property1.getDefaultValue(), propertyDefinition.getDefaultValue());
+ assertEquals("check property description", property1.getDescription(), propertyDefinition.getDescription());
+ assertEquals("check property type", property1.getType(), propertyDefinition.getType());
+ assertEquals("check property unique id", property1.getUniqueId(), propertyDefinition.getUniqueId());
+ assertEquals("check property consitraints size", property1.getConstraints().size(),
+ propertyDefinition.getConstraints().size());
+
+ return resultResource;
+
+ }
+
+ public static List<PropertyDefinition> convertMapToList(Map<String, PropertyDefinition> properties) {
+ if (properties == null) {
+ return null;
+ }
+
+ List<PropertyDefinition> definitions = new ArrayList<>();
+ for (Entry<String, PropertyDefinition> entry : properties.entrySet()) {
+ String name = entry.getKey();
+ PropertyDefinition propertyDefinition = entry.getValue();
+ propertyDefinition.setName(name);
+ definitions.add(propertyDefinition);
+ }
+
+ return definitions;
+ }
+
+ @Test
+ public void testFollowed() {
+ String rootName = "Root123";
+
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+
+ Resource rootResource = createResource(userId, category, rootName, "1.0", null, false, true);
+ log.debug(" *** create **");
+ log.debug("{}", rootResource);
+ String resourceId = rootResource.getUniqueId();
+
+ Set<LifecycleStateEnum> lifecycleStates = new HashSet<LifecycleStateEnum>();
+ lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ Set<LifecycleStateEnum> lastStateStates = new HashSet<LifecycleStateEnum>();
+ lastStateStates.add(LifecycleStateEnum.CERTIFIED);
+
+ Either<List<Resource>, StorageOperationStatus> followed = resourceOperation.getFollowed(userId, lifecycleStates,
+ lastStateStates, false);
+ assertTrue(followed.isLeft());
+ List<Resource> list = followed.left().value();
+
+ assertEquals(1, list.size());
+ resourceOperation.deleteResource(resourceId);
+
+ followed = resourceOperation.getFollowed(userId, lifecycleStates, lastStateStates, false);
+ assertTrue(followed.isLeft());
+ list = followed.left().value();
+ assertTrue(list.isEmpty());
+
+ }
+
+ @Ignore
+ @Test
+ public void testGetLatestVersion() {
+ String rootName = "Root123";
+
+ String userId = "jh0003";
+ String category = "category/mycategory";
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+
+ Either<Resource, StorageOperationStatus> latestByName = resourceOperation.getLatestByName(rootName, true);
+ assertTrue(latestByName.isRight());
+ assertEquals(StorageOperationStatus.NOT_FOUND, latestByName.right().value());
+
+ Resource rootResource = createResource(userId, category, rootName, "1.0", null, false, true);
+
+ latestByName = resourceOperation.getLatestByName(rootName, true);
+ assertTrue(latestByName.isLeft());
+
+ Resource rootResourceHighest = createResource(userId, category, rootName, "1.3", null, false, true);
+
+ latestByName = resourceOperation.getLatestByName(rootName, false);
+ assertTrue(latestByName.isLeft());
+ assertEquals(rootResourceHighest.getUniqueId(), latestByName.left().value().getUniqueId());
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+ resourceOperation.deleteResource(rootResourceHighest.getUniqueId());
+ }
+
+ @Test
+ public void testOverrideResource() {
+ String rootName = "Root123";
+
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ String updatedCategory = CATEGORY_NAME_UPDATED;
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+ deleteAndCreateCategory(updatedCategory);
+
+ Resource rootResource = createResource(userId, category, rootName, "1.1", null, false, true);
+
+ rootResource.setCategories(null);
+ String[] updateArr = updatedCategory.split("/");
+ rootResource.addCategory(updateArr[0], updateArr[1]);
+ List<PropertyDefinition> properties = rootResource.getProperties();
+ PropertyDefinition propertyDefinition = findProperty(properties, "disk_size");
+
+ rootResource.setProperties(new ArrayList<PropertyDefinition>());
+ propertyDefinition.setName("myProperty");
+ rootResource.getProperties().add(propertyDefinition);
+
+ Either<Resource, StorageOperationStatus> overrideResource = resourceOperation.overrideResource(rootResource,
+ rootResource, false);
+
+ assertTrue(overrideResource.isLeft());
+ Resource resourceAfter = overrideResource.left().value();
+ assertEquals(1, resourceAfter.getProperties().size());
+
+ assertNotNull(findProperty(resourceAfter.getProperties(), "myProperty"));
+ assertEquals(1, resourceAfter.getCategories().size());
+ assertEquals(1, resourceAfter.getCategories().get(0).getSubcategories().size());
+
+ assertEquals(updateArr[0], resourceAfter.getCategories().get(0).getName());
+ assertEquals(updateArr[1], resourceAfter.getCategories().get(0).getSubcategories().get(0).getName());
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+ }
+
+ @Test
+ public void testResourceWithCapabilities() {
+ String rootName = "Root123";
+
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ String updatedCategory = CATEGORY_NAME_UPDATED;
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+ deleteAndCreateCategory(updatedCategory);
+
+ Resource rootResource = createResource(userId, category, rootName, "1.1", null, false, true);
+
+ CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+ capabilityTypeDefinition.setType("tosca.capabilities.Container");
+ PropertyDefinition delaultProperty1 = new PropertyDefinition();
+ delaultProperty1.setName("def");
+ delaultProperty1.setType("string");
+ delaultProperty1.setDefaultValue("def");
+
+ PropertyDefinition delaultProperty2 = new PropertyDefinition();
+ delaultProperty2.setName("host");
+ delaultProperty2.setType("string");
+ delaultProperty2.setDefaultValue("true");
+
+ HashMap<String, PropertyDefinition> props = new HashMap<String, PropertyDefinition>();
+ props.put(delaultProperty1.getName(), delaultProperty1);
+ props.put(delaultProperty2.getName(), delaultProperty2);
+ capabilityTypeDefinition.setProperties(props);
+
+ Either<CapabilityTypeDefinition, StorageOperationStatus> addTypeRes = capabilityTypeOperation
+ .addCapabilityType(capabilityTypeDefinition);
+ assertTrue(addTypeRes.isLeft());
+
+ CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setDescription("firstCap");
+ capabilityDefinition.setName("firstCap");
+ capabilityDefinition.setType("tosca.capabilities.Container");
+
+ List<ComponentInstanceProperty> properties = new ArrayList<ComponentInstanceProperty>();
+ ComponentInstanceProperty propertyDefinition1 = new ComponentInstanceProperty();
+ propertyDefinition1.setName("version");
+ propertyDefinition1.setType("string");
+ propertyDefinition1.setDefaultValue("007");
+ properties.add(propertyDefinition1);
+
+ ComponentInstanceProperty propertyDefinition2 = new ComponentInstanceProperty();
+ propertyDefinition2.setName("host");
+ propertyDefinition2.setType("string");
+ propertyDefinition2.setDefaultValue("localhost");
+ properties.add(propertyDefinition2);
+
+ capabilityDefinition.setProperties(properties);
+
+ Either<CapabilityDefinition, StorageOperationStatus> addCapabilityRes = capabilityOperation
+ .addCapability(rootResource.getUniqueId(), capabilityDefinition.getName(), capabilityDefinition);
+ assertTrue(addCapabilityRes.isLeft());
+
+ List<PropertyDefinition> newProperties = new ArrayList<PropertyDefinition>();
+ propertyDefinition1 = new ComponentInstanceProperty();
+ propertyDefinition1.setName("num_cpu");
+ propertyDefinition1.setType("string");
+ propertyDefinition1.setDefaultValue("4");
+ newProperties.add(propertyDefinition1);
+
+ propertyDefinition2 = new ComponentInstanceProperty();
+ propertyDefinition2.setName("port");
+ propertyDefinition2.setType("string");
+ propertyDefinition2.setDefaultValue("4444");
+ newProperties.add(propertyDefinition2);
+
+ CapabilityDefinition addedCap = addCapabilityRes.left().value();
+
+ Either<Map<String, PropertyData>, StorageOperationStatus> updatePropertiesRes = capabilityOperation
+ .updatePropertiesOfCapability(addedCap.getUniqueId(), addedCap.getType(), newProperties);
+ assertTrue(updatePropertiesRes.isLeft());
+
+ PropertyDefinition invalidProperty = new PropertyDefinition();
+ invalidProperty.setName("port");
+ invalidProperty.setType("rrr");
+ invalidProperty.setDefaultValue("666");
+ newProperties.add(invalidProperty);
+
+ Either<Map<String, PropertyData>, StorageOperationStatus> updatePropertiesInvalidRes = capabilityOperation
+ .updatePropertiesOfCapability(addedCap.getUniqueId(), addedCap.getType(), newProperties);
+ assertTrue(updatePropertiesInvalidRes.isRight());
+
+ Either<CapabilityDefinition, StorageOperationStatus> getCapabilityRes = capabilityOperation
+ .getCapability(addedCap.getUniqueId());
+ assertTrue(getCapabilityRes.isLeft());
+
+ Either<List<ImmutablePair<PropertyData, GraphEdge>>, TitanOperationStatus> deletePropertiesOfCapabilityRes = capabilityOperation
+ .deletePropertiesOfCapability(addedCap.getUniqueId());
+ assertTrue(deletePropertiesOfCapabilityRes.isLeft());
+
+ StorageOperationStatus deleteCapabilityRes = capabilityOperation
+ .deleteCapabilityFromGraph(addedCap.getUniqueId());
+ assertTrue(deleteCapabilityRes.equals(StorageOperationStatus.OK));
+
+ getCapabilityRes = capabilityOperation.getCapability(addedCap.getUniqueId());
+ assertTrue(getCapabilityRes.isRight()
+ && getCapabilityRes.right().value().equals(StorageOperationStatus.NOT_FOUND));
+
+ resourceOperation.deleteResource(rootResource.getUniqueId());
+ }
+
+ private PropertyDefinition findProperty(List<PropertyDefinition> properties, String propName) {
+
+ if (properties == null) {
+ return null;
+ }
+
+ for (PropertyDefinition propertyDefinition : properties) {
+ String name = propertyDefinition.getName();
+ if (name.equals(propName)) {
+ return propertyDefinition;
+ }
+ }
+
+ return null;
+ }
+
+ @Test
+ public void testOverrideResourceNotExist() {
+ String rootName = "Root123";
+
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+
+ Resource rootResource = buildResourceMetadata(userId, category, rootName, "1.1");
+ rootResource.setUniqueId(UniqueIdBuilder.buildResourceUniqueId());
+
+ Either<Resource, StorageOperationStatus> overrideResource = resourceOperation.overrideResource(rootResource,
+ rootResource, false);
+
+ assertTrue(overrideResource.isRight());
+
+ }
+
+ @Ignore
+ @Test
+ public void testCatalogResource() {
+ String resName = "myResource";
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ deleteAndCreateCategory(category);
+ // resourceOperation.deleteResource(UniqueIdBuilder.buildResourceUniqueId(resName,"0.1"));
+ Resource newResource = createResource(userId, category, resName, "0.1", null, false, true);
+ String resourceId = newResource.getUniqueId();
+
+ Map<String, Object> propertiesToMatch = new HashMap<>();
+ propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
+
+ Either<Set<Resource>, StorageOperationStatus> catalog = resourceOperation.getCatalogData(propertiesToMatch,
+ false);
+ assertTrue(catalog.isLeft());
+ Set<Resource> catalogSet = catalog.left().value();
+ Set<String> idSet = new HashSet<>();
+ for (Resource resource : catalogSet) {
+ idSet.add(resource.getUniqueId());
+ }
+ assertTrue(idSet.contains(resourceId));
+ resourceOperation.deleteResource(resourceId);
+ }
+
+ @Ignore
+ @Test
+ public void testTesterFollowed() {
+ String rootName = "Test1";
+ String rootName2 = "Test2";
+ String rootName3 = "Test3";
+ String userId = "jh0003";
+ String testerUserId = "tt0004";
+ String category = CATEGORY_NAME;
+ deleteAndCreateUser(testerUserId, "tester", "last");
+ deleteAndCreateCategory(category);
+
+ String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
+ Either<UserData, TitanOperationStatus> findUser = titanDao.getNode(key, userId, UserData.class);
+ User adminUser = OperationTestsUtil.convertUserDataToUser(findUser.left().value());
+ Either<UserData, TitanOperationStatus> findTesterUser = titanDao.getNode(key, testerUserId, UserData.class);
+ User testerUser = OperationTestsUtil.convertUserDataToUser(findTesterUser.left().value());
+
+ // Create 3 new resources
+ Resource resultResource = createResource(userId, category, rootName, "1.0", null, false, true);
+ log.debug("{}", resultResource);
+ String resourceId = resultResource.getUniqueId();
+ Resource resultResource2 = createResource(userId, category, rootName2, "1.0", null, false, true);
+ log.debug("{}", resultResource2);
+ String resourceId2 = resultResource2.getUniqueId();
+ Resource resultResource3 = createResource(userId, category, rootName3, "1.0", null, false, true);
+ log.debug("{}", resultResource3);
+ String resourceId3 = resultResource3.getUniqueId();
+
+ // update 1 resource to READY_FOR_CERTIFICATION
+ Either<Resource, StorageOperationStatus> certReqResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Resource, resultResource, adminUser, adminUser, false);
+ Resource RFCResource = certReqResponse.left().value();
+ assertEquals(RFCResource.getLifecycleState(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+
+ // update 1 resource to CERTIFICATION_IN_PROGRESS
+ Either<Resource, StorageOperationStatus> startCertificationResponse = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Resource, resultResource2, testerUser, adminUser, false);
+ Resource IPResource = startCertificationResponse.left().value();
+ assertEquals(IPResource.getLifecycleState(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+
+ Set<LifecycleStateEnum> lifecycleStates = new HashSet<LifecycleStateEnum>();
+ lifecycleStates.add(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+
+ Either<List<Resource>, StorageOperationStatus> resources = resourceOperation.getTesterFollowed(testerUserId,
+ lifecycleStates, false);
+
+ assertTrue(resources.isLeft());
+ List<Resource> result = resources.left().value();
+
+ List<String> idSet = new ArrayList();
+ for (Resource resource : result) {
+ idSet.add(resource.getUniqueId());
+ }
+ assertTrue(idSet.contains(resourceId));
+ assertTrue(idSet.contains(resourceId2));
+ assertFalse(idSet.contains(resourceId3));
+ resourceOperation.deleteResource(resourceId);
+ resourceOperation.deleteResource(resourceId2);
+ resourceOperation.deleteResource(resourceId3);
+
+ }
+
+ @Test
+ public void getVersionListNotDeleted() {
+ String resName = "myResource";
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ deleteAndCreateCategory(category);
+
+ Resource newResource = createResource(userId, category, resName, "0.1", null, false, true);
+ String resourceId1 = newResource.getUniqueId();
+
+ User admin = new User("j", "h", userId, null, "ADMIN", System.currentTimeMillis());
+ Either<Resource, StorageOperationStatus> checkoutResource = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, newResource, admin, admin, false);
+ assertTrue(checkoutResource.isLeft());
+ Resource newResource2 = checkoutResource.left().value();
+ String resourceId2 = newResource2.getUniqueId();
+
+ Resource newResource3 = createResource(userId, category, resName, "0.1", null, false, true);
+ String resourceId3 = newResource3.getUniqueId();
+
+ Either<Map<String, String>, TitanOperationStatus> versionList = resourceOperation.getVersionList(
+ NodeTypeEnum.Resource, "0.2", newResource2.getUUID(), newResource2.getSystemName(),
+ ResourceMetadataData.class);
+ assertTrue(versionList.isLeft());
+ Map<String, String> versionMap = versionList.left().value();
+
+ assertTrue(versionMap.size() == 2);
+ assertTrue(versionMap.containsValue(resourceId1));
+ assertTrue(versionMap.containsValue(resourceId2));
+ assertFalse(versionMap.containsValue(resourceId3));
+
+ Either<Resource, StorageOperationStatus> deleteResource = resourceOperation.deleteResource(resourceId1);
+ assertTrue(deleteResource.isLeft());
+ deleteResource = resourceOperation.deleteResource(resourceId2);
+ assertTrue(deleteResource.isLeft());
+ deleteResource = resourceOperation.deleteResource(resourceId3);
+ assertTrue(deleteResource.isLeft());
+
+ }
+
+ @Test
+ public void getVersionListWithDeleted() {
+ String resName = "myResource";
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+ deleteAndCreateCategory(category);
+
+ Resource newResource = createResource(userId, category, resName, "0.1", null, false, true);
+ String resourceId1 = newResource.getUniqueId();
+
+ User admin = new User("j", "h", userId, null, "ADMIN", System.currentTimeMillis());
+ Either<Resource, StorageOperationStatus> checkoutResource = (Either<Resource, StorageOperationStatus>) lifecycleOperation
+ .checkoutComponent(NodeTypeEnum.Resource, newResource, admin, admin, false);
+ assertTrue(checkoutResource.isLeft());
+ Resource newResource2 = checkoutResource.left().value();
+ String resourceId2 = newResource2.getUniqueId();
+
+ Either<Resource, StorageOperationStatus> resource = resourceOperation.getResource(resourceId1, false);
+ assertTrue(resource.isLeft());
+ Either<Component, StorageOperationStatus> markResourceToDelete = resourceOperation
+ .markComponentToDelete(resource.left().value(), false);
+ assertTrue(markResourceToDelete.isLeft());
+
+ Either<Map<String, String>, TitanOperationStatus> versionList = resourceOperation.getVersionList(
+ NodeTypeEnum.Resource, "0.2", newResource2.getUUID(), newResource2.getSystemName(),
+ ResourceMetadataData.class);
+
+ assertTrue(versionList.isLeft());
+ Map<String, String> versionMap = versionList.left().value();
+
+ assertTrue(versionMap.size() == 1);
+ assertFalse(versionMap.containsValue(resourceId1));
+ assertTrue(versionMap.containsValue(resourceId2));
+
+ Either<Resource, StorageOperationStatus> deleteResource = resourceOperation.deleteResource(resourceId1);
+ assertTrue(deleteResource.isLeft());
+ deleteResource = resourceOperation.deleteResource(resourceId2);
+ assertTrue(deleteResource.isLeft());
+ }
+
+ @Test
+ public void testDerviedPropertiesInResource() {
+
+ try {
+ String userId = "jh0003";
+ String category = CATEGORY_NAME;
+
+ deleteAndCreateUser(userId, "first_" + userId, "last_" + userId);
+ deleteAndCreateCategory(category);
+
+ Resource createResource1 = createResource(userId, category, "myResource1", "0.1", null, true, false);
+ ResourceMetadataData resourceData = new ResourceMetadataData();
+ resourceData.getMetadataDataDefinition().setUniqueId(createResource1.getUniqueId());
+ resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
+ Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData,
+ ResourceMetadataData.class);
+ assertTrue(updateNode.isLeft());
+
+ Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+ String json = gson.toJson(createResource1);
+ log.debug(json);
+
+ Resource createResource2 = createResource(userId, category, "myResource2", "0.1", createResource1.getName(),
+ true, false);
+
+ json = gson.toJson(createResource2);
+ log.debug(json);
+
+ List<PropertyDefinition> propList1 = new ArrayList<>();
+ TitanOperationStatus findAllResourcePropertiesRecursively1 = propertyOperation
+ .findAllResourcePropertiesRecursively(createResource1.getUniqueId(), propList1);
+ assertEquals("check search properties succeed", findAllResourcePropertiesRecursively1,
+ TitanOperationStatus.OK);
+
+ List<PropertyDefinition> propList2 = new ArrayList<>();
+ TitanOperationStatus findAllResourcePropertiesRecursively2 = propertyOperation
+ .findAllResourcePropertiesRecursively(createResource2.getUniqueId(), propList2);
+ assertEquals("check search properties succeed", findAllResourcePropertiesRecursively2,
+ TitanOperationStatus.OK);
+
+ assertEquals("check number of properties", propList1.size() * 2, propList2.size());
+
+ resourceOperation.deleteResource(createResource1.getUniqueId());
+ resourceOperation.deleteResource(createResource2.getUniqueId());
+
+ } finally {
+
+ }
+
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperationTest.java
new file mode 100644
index 0000000000..81a5a5ed1d
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ServiceOperationTest.java
@@ -0,0 +1,964 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+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.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.ArtifactDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.DistributionStatusEnum;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
+import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
+import org.openecomp.sdc.be.resources.data.ArtifactData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.thinkaurelius.titan.core.TitanGraph;
+//import com.tinkerpop.blueprints.Vertex;
+import com.thinkaurelius.titan.core.TitanVertex;
+
+import fj.data.Either;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ServiceOperationTest extends ModelTestBase {
+
+ @javax.annotation.Resource(name = "titan-generic-dao")
+ private TitanGenericDao titanDao;
+
+ @javax.annotation.Resource(name = "service-operation")
+ private ServiceOperation serviceOperation;
+
+ @javax.annotation.Resource
+ private IGraphLockOperation graphLockOperation;
+
+ @javax.annotation.Resource
+ private ArtifactOperation artifactOperation;
+
+ @javax.annotation.Resource(name = "requirement-operation")
+ private RequirementOperation requirementOperation;
+
+ @javax.annotation.Resource(name = "resource-operation")
+ private ResourceOperation resourceOperation;
+
+ @javax.annotation.Resource(name = "property-operation")
+ private PropertyOperation propertyOperation;
+
+ @javax.annotation.Resource(name = "capability-operation")
+ private CapabilityOperation capabilityOperation;
+
+ @javax.annotation.Resource(name = "capability-type-operation")
+ private CapabilityTypeOperation capabilityTypeOperation;
+
+ @javax.annotation.Resource(name = "component-instance-operation")
+ private ComponentInstanceOperation resourceInstanceOperation;
+
+ @javax.annotation.Resource(name = "lifecycle-operation")
+ private LifecycleOperation lifecycleOperation;
+
+ private static Logger log = LoggerFactory.getLogger(ServiceOperation.class.getName());
+ private static String USER_ID = "muserId";
+ private static String CATEGORY_NAME = "category/mycategory";
+
+ @BeforeClass
+ public static void setupBeforeClass() {
+ // ExternalConfiguration.setAppName("catalog-model");
+ // String appConfigDir = "src/test/resources/config/catalog-model";
+ // ConfigurationSource configurationSource = new
+ // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ // appConfigDir);
+
+ // configurationManager = new ConfigurationManager(new
+ // ConfigurationSource() {
+ //
+ // @Override
+ // public <T> T getAndWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ // return null;
+ // }
+ //
+ // @Override
+ // public <T> void addWatchConfiguration(Class<T> className,
+ // ConfigurationListener configurationListener) {
+ // // TODO Auto-generated method stub
+ //
+ // }
+ // });
+
+ // String appConfigDir = "src/test/resources/config";
+ // ConfigurationSource configurationSource = new
+ // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ // appConfigDir);
+ // configurationManager = new ConfigurationManager(configurationSource);
+ //
+ // Configuration configuration = new Configuration();
+ // configuration.setTitanInMemoryGraph(true);
+ //// configuration.setTitanInMemoryGraph(false);
+ //// configuration.setTitanCfgFile("C:\\Dev\\d2\\D2-SDnC\\catalog-be\\src\\main\\resources\\config\\titan.properties");
+ //
+ // configurationManager.setConfiguration(configuration);
+
+ ModelTestBase.init();
+ }
+
+ @Before
+ public void createUserAndCategory() {
+ deleteAndCreateCategory(CATEGORY_NAME);
+ deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, null);
+ }
+
+ @Test
+ public void dummyTest() {
+
+ }
+
+ @Test
+ public void testCreateService() {
+ String category = CATEGORY_NAME;
+ String serviceName = "servceTest";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug(" *** create **");
+ log.debug("{}", serviceAfterSave);
+ String uniqueId = serviceAfterSave.getUniqueId();
+
+ Either<Service, StorageOperationStatus> serviceGet = serviceOperation.getService(uniqueId);
+ assertTrue(serviceGet.isLeft());
+ log.debug(" *** get **");
+ log.debug("{}", serviceGet.left().value());
+
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation.deleteService(uniqueId);
+
+ assertTrue(serviceDelete.isLeft());
+ log.debug(" *** delete **");
+ log.debug("{}", serviceDelete.left().value());
+
+ Either<List<ArtifactData>, TitanOperationStatus> artifacts = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef,
+ null, ArtifactData.class);
+ assertTrue(artifacts.isRight());
+ assertEquals(TitanOperationStatus.NOT_FOUND, artifacts.right().value());
+
+ serviceOperation.deleteService(serviceAfterSave.getUniqueId());
+ }
+
+ @Test
+ public void testUtilsService() {
+ String category = CATEGORY_NAME;
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug(" *** create **");
+ log.debug("{}", serviceAfterSave);
+ String uniqueId = serviceAfterSave.getUniqueId();
+
+ boolean canWorkOnComponent = ComponentValidationUtils.canWorkOnComponent(uniqueId, serviceOperation, userId);
+ assertTrue(canWorkOnComponent);
+
+ canWorkOnComponent = ComponentValidationUtils.canWorkOnComponent(serviceAfterSave, userId);
+ assertTrue(canWorkOnComponent);
+
+ StorageOperationStatus lockComponent = graphLockOperation.lockComponent(uniqueId, NodeTypeEnum.Service);
+ assertEquals(StorageOperationStatus.OK, lockComponent);
+
+ lockComponent = graphLockOperation.unlockComponent(uniqueId, NodeTypeEnum.Service);
+ assertEquals(StorageOperationStatus.OK, lockComponent);
+
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation.deleteService(uniqueId);
+ }
+
+ @Test
+ public void testInstanceCounter() {
+ String category = CATEGORY_NAME;
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug(" *** create **");
+ log.debug("{}", serviceAfterSave);
+
+ Either<Integer, StorageOperationStatus> counter = serviceOperation
+ .increaseAndGetComponentInstanceCounter(serviceAfterSave.getUniqueId(), NodeTypeEnum.Service, false);
+ assertTrue(counter.isLeft());
+ assertEquals(new Integer(1), (Integer) counter.left().value());
+
+ counter = serviceOperation.increaseAndGetComponentInstanceCounter(serviceAfterSave.getUniqueId(),
+ NodeTypeEnum.Service, false);
+ assertTrue(counter.isLeft());
+ assertEquals(new Integer(2), (Integer) counter.left().value());
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation
+ .deleteService(serviceAfterSave.getUniqueId());
+ }
+
+ @Test
+ public void testAddArtifactToService() {
+ String category = CATEGORY_NAME;
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+
+ ArtifactDefinition artifactInfo = addArtifactToService(userId, serviceId, "install_apache");
+
+ Either<Service, StorageOperationStatus> service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ Map<String, ArtifactDefinition> artifacts = service.left().value().getArtifacts();
+ assertEquals(1, artifacts.size());
+
+ for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
+ String artifactId = entry.getValue().getUniqueId();
+ String description = entry.getValue().getDescription();
+ assertEquals("hdkfhskdfgh", description);
+
+ artifactInfo.setDescription("jghlsk new desfnjdh");
+
+ artifactOperation.updateArifactOnResource(artifactInfo, serviceId, artifactId, NodeTypeEnum.Service, false);
+ }
+
+ service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ artifacts = service.left().value().getArtifacts();
+ for (Map.Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
+ String artifactId = entry.getValue().getUniqueId();
+ String description = entry.getValue().getDescription();
+ assertEquals("jghlsk new desfnjdh", description);
+
+ artifactOperation.removeArifactFromResource(serviceId, artifactId, NodeTypeEnum.Service, true, false);
+ }
+ service = serviceOperation.getService(serviceId);
+ assertTrue(service.isLeft());
+
+ artifacts = service.left().value().getArtifacts();
+ assertEquals(0, artifacts.size());
+
+ Either<Service, StorageOperationStatus> serviceDelete = serviceOperation.deleteService(serviceId);
+
+ Either<List<ArtifactData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef,
+ null, ArtifactData.class);
+ assertTrue(byCriteria.isRight());
+ assertEquals(TitanOperationStatus.NOT_FOUND, byCriteria.right().value());
+
+ serviceOperation.deleteService(serviceAfterSave.getUniqueId());
+
+ }
+
+ private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
+ ArtifactDefinition artifactInfo = new ArtifactDefinition();
+
+ artifactInfo.setArtifactName(artifactName + ".sh");
+ artifactInfo.setArtifactType("SHELL");
+ artifactInfo.setDescription("hdkfhskdfgh");
+ artifactInfo.setPayloadData("UEsDBAoAAAAIAAeLb0bDQz");
+
+ artifactInfo.setUserIdCreator(userId);
+ String fullName = "Jim H";
+ artifactInfo.setUpdaterFullName(fullName);
+ long time = System.currentTimeMillis();
+ artifactInfo.setCreatorFullName(fullName);
+ artifactInfo.setCreationDate(time);
+ artifactInfo.setLastUpdateDate(time);
+
+ artifactInfo.setUserIdLastUpdater(userId);
+ artifactInfo.setArtifactLabel(artifactName);
+ artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
+
+ Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation
+ .addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
+ assertTrue(artifact.isLeft());
+ return artifactInfo;
+ }
+
+ @Test
+ public void testFollowed() {
+ String category = CATEGORY_NAME;
+ String serviceName = "servceTest2";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+
+ Set<LifecycleStateEnum> lifecycleStates = new HashSet<LifecycleStateEnum>();
+ lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ Set<LifecycleStateEnum> lastStateStates = new HashSet<LifecycleStateEnum>();
+ lastStateStates.add(LifecycleStateEnum.CERTIFIED);
+
+ Either<List<Service>, StorageOperationStatus> followed = serviceOperation.getFollowed(userId, lifecycleStates,
+ lastStateStates, false);
+ assertTrue(followed.isLeft());
+ List<Service> list = followed.left().value();
+ assertEquals(1, list.size());
+ serviceOperation.deleteService(serviceId);
+ }
+
+ @Test
+ public void testUpdateService() {
+ String category = CATEGORY_NAME;
+ String serviceName = "12";
+ String serviceVersion = "0.1";
+ String userId = USER_ID;
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+ serviceAfterSave.setDescription("new description");
+ Either<Service, StorageOperationStatus> updateService = serviceOperation.updateService(serviceAfterSave, false);
+ assertTrue(updateService.isLeft());
+
+ titanDao.commit();
+
+ Either<Service, StorageOperationStatus> serviceAfterUpdate = serviceOperation.getService(serviceId, false);
+ assertTrue(serviceAfterUpdate.isLeft());
+
+ serviceOperation.deleteService(serviceId);
+ assertEquals("new description", serviceAfterUpdate.left().value().getDescription());
+
+ }
+
+ public Service createService(String userId, String category, String serviceName, String serviceVersion,
+ boolean isHighestVersion) {
+
+ Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
+
+ service.setHighestVersion(isHighestVersion);
+
+ Either<Service, StorageOperationStatus> result = serviceOperation.createService(service, true);
+
+ log.info(result.toString());
+ assertTrue(result.isLeft());
+ Service resultService = result.left().value();
+
+ // assertEquals("check resource unique id",
+ // UniqueIdBuilder.buildServiceUniqueId(serviceName, serviceVersion),
+ // resultService.getUniqueId());
+ assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
+ resultService.getLifecycleState());
+
+ return resultService;
+ }
+
+ // @Test
+ public void testCloneFullService() {
+ // try{
+ String userId = USER_ID;
+ // Either<Service, StorageOperationStatus> deleteService =
+ // serviceOperation.deleteService(UniqueIdBuilder.buildServiceUniqueId("my-service",
+ // "1.0"), false);
+ // log.info("testCloneFullService - after delete service. result
+ // is="+deleteService);
+ Service origService = createService(userId, CATEGORY_NAME, "my-service", "1.0", true);
+
+ // add artifacts
+ addArtifactToService(userId, origService.getUniqueId(), "install_apache");
+ addArtifactToService(userId, origService.getUniqueId(), "start_apache");
+
+ // add resource instances
+ ResourceInstanceOperationTest riTest = new ResourceInstanceOperationTest();
+ riTest.setOperations(titanDao, capabilityTypeOperation, requirementOperation, capabilityOperation,
+ resourceOperation, propertyOperation, resourceInstanceOperation);
+ riTest.addResourceInstancesAndRelation(origService.getUniqueId());
+
+ Either<Service, StorageOperationStatus> service2 = serviceOperation.getService(origService.getUniqueId(),
+ false);
+ assertTrue(service2.isLeft());
+ origService = service2.left().value();
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(origService);
+ log.debug(json);
+
+ Service fullService = origService;
+
+ Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0",
+ false);
+ assertTrue(createService.isLeft());
+ Either<Service, StorageOperationStatus> serviceAfterCreate = serviceOperation
+ .getServiceByNameAndVersion("my-service", "2.0", null, false);
+ assertTrue(serviceAfterCreate.isLeft());
+ fullService = serviceAfterCreate.left().value();
+
+ Either<Service, StorageOperationStatus> getOrigService = serviceOperation
+ .getServiceByNameAndVersion("my-service", "1.0", null, false);
+ assertTrue(getOrigService.isLeft());
+ origService = getOrigService.left().value();
+
+ // assertEquals(origService.getComponentMetadataDefinition(),
+ // fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getArtifacts().size(), fullService.getArtifacts().size());
+ assertEquals(origService.getComponentInstances().size(), fullService.getComponentInstances().size());
+ assertEquals(origService.getComponentInstancesRelations().size(),
+ fullService.getComponentInstancesRelations().size());
+
+ origService.setUniqueId(fullService.getUniqueId());
+ origService.setVersion(fullService.getVersion());
+
+ assertEquals(origService.getComponentMetadataDefinition(), fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getCategories(), fullService.getCategories());
+
+ serviceOperation.deleteService(origService.getUniqueId());
+ serviceOperation.deleteService(serviceAfterCreate.left().value().getUniqueId());
+
+ // } finally {
+ // titanDao.rollback();
+ // Either<Service, StorageOperationStatus> serviceAfterCreate =
+ // serviceOperation.getService(UniqueIdBuilder.buildServiceUniqueId("my-service",
+ // "2.0"), true);
+ // assertTrue(serviceAfterCreate.isRight());
+ //
+ // Either<Service, StorageOperationStatus> getOrigService =
+ // serviceOperation.getService(UniqueIdBuilder.buildServiceUniqueId("my-service",
+ // "1.0"), true);
+ // assertTrue(getOrigService.isRight());
+ // titanDao.rollback();
+ // }
+ }
+
+ // @Test
+ public void testCloneServiceWithoutResourceInstances() {
+ // try{
+ String userId = USER_ID;
+ // Either<Service, StorageOperationStatus> deleteService =
+ // serviceOperation.deleteService(UniqueIdBuilder.buildServiceUniqueId("my-service",
+ // "1.0"), false);
+ // log.info("testCloneServiceWithoutResourceInstances - after delete
+ // service. result is="+deleteService);
+ Service origService = createService(userId, CATEGORY_NAME, "my-service", "1.0", true);
+
+ // add artifacts
+ addArtifactToService(userId, origService.getUniqueId(), "install_apache");
+ addArtifactToService(userId, origService.getUniqueId(), "start_apache");
+
+ Either<Service, StorageOperationStatus> service2 = serviceOperation.getService(origService.getUniqueId(),
+ false);
+ assertTrue(service2.isLeft());
+ origService = service2.left().value();
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(origService);
+ log.debug(json);
+
+ Service fullService = origService;
+
+ Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0",
+ false);
+ assertTrue(createService.isLeft());
+ Either<Service, StorageOperationStatus> serviceAfterCreate = serviceOperation
+ .getServiceByNameAndVersion("my-service", "2.0", null, false);
+ assertTrue(serviceAfterCreate.isLeft());
+ fullService = serviceAfterCreate.left().value();
+
+ Either<Service, StorageOperationStatus> getOrigService = serviceOperation
+ .getServiceByNameAndVersion("my-service", "1.0", null, false);
+ assertTrue(getOrigService.isLeft());
+ origService = getOrigService.left().value();
+
+ // assertEquals(origService.getComponentMetadataDefinition(),
+ // fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getArtifacts().size(), fullService.getArtifacts().size());
+ assertEquals(origService.getComponentInstances(), fullService.getComponentInstances());
+ assertEquals(origService.getComponentInstancesRelations(), fullService.getComponentInstancesRelations());
+
+ origService.setUniqueId(fullService.getUniqueId());
+ origService.setVersion(fullService.getVersion());
+
+ assertEquals(origService.getComponentMetadataDefinition(), fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getCategories(), fullService.getCategories());
+
+ serviceOperation.deleteService(getOrigService.left().value().getUniqueId());
+ serviceOperation.deleteService(serviceAfterCreate.left().value().getUniqueId());
+
+ // } finally {
+ // titanDao.rollback();
+ // }
+ }
+
+ // @Test
+ public void testCloneServiceWithoutArtifacts() {
+ // try{
+
+ String userId = USER_ID;
+
+ Service origService = createService(userId, CATEGORY_NAME, "my-service", "1.0", true);
+
+ // add resource instances
+ ResourceInstanceOperationTest riTest = new ResourceInstanceOperationTest();
+ riTest.setOperations(titanDao, capabilityTypeOperation, requirementOperation, capabilityOperation,
+ resourceOperation, propertyOperation, resourceInstanceOperation);
+ riTest.addResourceInstancesAndRelation(origService.getUniqueId());
+
+ Either<Service, StorageOperationStatus> service2 = serviceOperation.getService(origService.getUniqueId(),
+ false);
+ assertTrue(service2.isLeft());
+ origService = service2.left().value();
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(origService);
+ log.debug(json);
+
+ Service fullService = origService;
+
+ Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0",
+ false);
+ assertTrue(createService.isLeft());
+ Either<Service, StorageOperationStatus> serviceAfterCreate = serviceOperation
+ .getServiceByNameAndVersion("my-service", "2.0", null, false);
+ assertTrue(serviceAfterCreate.isLeft());
+ fullService = serviceAfterCreate.left().value();
+
+ Either<Service, StorageOperationStatus> getOrigService = serviceOperation
+ .getServiceByNameAndVersion("my-service", "1.0", null, false);
+ assertTrue(getOrigService.isLeft());
+ origService = getOrigService.left().value();
+
+ assertEquals(origService.getArtifacts(), fullService.getArtifacts());
+ assertEquals(origService.getComponentInstances().size(), fullService.getComponentInstances().size());
+ assertEquals(origService.getComponentInstancesRelations().size(),
+ fullService.getComponentInstancesRelations().size());
+
+ origService.setUniqueId(fullService.getUniqueId());
+ origService.setVersion(fullService.getVersion());
+
+ assertEquals(origService.getComponentMetadataDefinition(), fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getCategories(), fullService.getCategories());
+
+ serviceOperation.deleteService(serviceAfterCreate.left().value().getUniqueId());
+ serviceOperation.deleteService(getOrigService.left().value().getUniqueId());
+
+ // } finally {
+ // titanDao.rollback();
+ // }
+ }
+
+ // @Test
+ public void testCloneServiceSimple() {
+ // try{
+ String userId = USER_ID;
+ String serviceName = "serviceToClone";
+ //
+ // Either<Service, StorageOperationStatus> deleteService =
+ // serviceOperation.deleteService(UniqueIdBuilder.buildServiceUniqueId(serviceName,
+ // "1.0"));
+ // log.info("testCloneServiceSimple - after delete service. result
+ // is="+deleteService);
+
+ Service origService = createService(userId, CATEGORY_NAME, serviceName, "1.0", true);
+
+ Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
+ String json = prettyGson.toJson(origService);
+ log.debug(json);
+
+ Service fullService = origService;
+
+ Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0",
+ false);
+ assertTrue(createService.isLeft());
+ Either<Service, StorageOperationStatus> serviceAfterCreate = serviceOperation
+ .getServiceByNameAndVersion(serviceName, "2.0", null, false);
+ assertTrue(serviceAfterCreate.isLeft());
+ fullService = serviceAfterCreate.left().value();
+
+ Either<Service, StorageOperationStatus> getOrigService = serviceOperation
+ .getServiceByNameAndVersion(serviceName, "1.0", null, false);
+ assertTrue(getOrigService.isLeft());
+ origService = getOrigService.left().value();
+
+ // assertEquals(origService.getComponentMetadataDefinition(),
+ // fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getArtifacts(), fullService.getArtifacts());
+ assertEquals(origService.getComponentInstances(), fullService.getComponentInstances());
+ assertEquals(origService.getComponentInstancesRelations(), fullService.getComponentInstancesRelations());
+ origService.setUniqueId(fullService.getUniqueId());
+ origService.setVersion(fullService.getVersion());
+
+ assertEquals(origService.getComponentMetadataDefinition(), fullService.getComponentMetadataDefinition());
+ assertEquals(origService.getCategories(), fullService.getCategories());
+
+ serviceOperation.deleteService(getOrigService.left().value().getUniqueId());
+ serviceOperation.deleteService(serviceAfterCreate.left().value().getUniqueId());
+
+ // } finally {
+ // titanDao.rollback();
+ // }
+ }
+
+ private Service buildServiceMetadata(String userId, String category, String serviceName, String serviceVersion) {
+
+ Service service = new Service();
+ service.setName(serviceName);
+ service.setVersion(serviceVersion);
+ service.setDescription("description 1");
+
+ service.setCreatorUserId(userId);
+ service.setContactId("contactId@sdc.com");
+ CategoryDefinition categoryDef = new CategoryDefinition();
+ categoryDef.setName(category);
+
+ List<CategoryDefinition> categories = new ArrayList<>();
+ categories.add(categoryDef);
+ service.setCategories(categories);
+
+ service.setIcon("images/my.png");
+ List<String> tags = new ArrayList<String>();
+ tags.add("TAG1");
+ tags.add("TAG2");
+ service.setTags(tags);
+ return service;
+ }
+
+ private void deleteAndCreateCategory(String category) {
+ String[] names = category.split("/");
+ OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao);
+ OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
+
+ /*
+ * CategoryData categoryData = new CategoryData();
+ * categoryData.setName(category);
+ *
+ * titanDao.deleteNode(categoryData, CategoryData.class);
+ * Either<CategoryData, TitanOperationStatus> createNode =
+ * titanDao.createNode(categoryData, CategoryData.class);
+ * System.out.println("after creating caetgory " + createNode);
+ */
+
+ }
+
+ private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setFirstName(firstName);
+ userData.setLastName(lastName);
+ if (role != null && !role.isEmpty()) {
+ userData.setRole(role);
+ } else {
+ userData.setRole("ADMIN");
+ }
+
+ titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
+ titanDao.createNode(userData, UserData.class);
+ titanDao.commit();
+
+ return userData;
+ }
+
+ @Test
+ public void testCatalogService() {
+ String userId = USER_ID;
+ String category = CATEGORY_NAME;
+ String serviceName = "MyService";
+ String serviceVersion = "0.1";
+ Service serviceAfterSave = createService(userId, category, serviceName, serviceVersion, true);
+ log.debug("{}", serviceAfterSave);
+ String serviceId = serviceAfterSave.getUniqueId();
+
+ Map<String, Object> propertiesToMatch = new HashMap<>();
+ propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
+
+ Either<Set<Service>, StorageOperationStatus> catalog = serviceOperation.getCatalogData(propertiesToMatch,
+ false);
+ assertTrue(catalog.isLeft());
+ Set<Service> catalogSet = catalog.left().value();
+ Set<String> idSet = new HashSet<>();
+ for (Service service : catalogSet) {
+ idSet.add(service.getUniqueId());
+ }
+ assertTrue(idSet.contains(serviceId));
+ serviceOperation.deleteService(serviceId);
+ }
+
+ @After
+ public void teardown() {
+ clearGraph();
+ }
+
+ private void clearGraph() {
+ Either<TitanGraph, TitanOperationStatus> graphResult = titanDao.getGraph();
+ TitanGraph graph = graphResult.left().value();
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ TitanVertex vertex = iterator.next();
+ // graph.removeVertex(vertex);
+ vertex.remove();
+ }
+
+ }
+ titanDao.commit();
+ }
+
+ @Test
+ public void testTesterFollowed() {
+ String serviceName = "Test1";
+ String serviceName2 = "Test2";
+ String serviceName3 = "Test3";
+ String userId = USER_ID;
+ String testerUserId = "tt0004";
+ String category = CATEGORY_NAME;
+ deleteAndCreateUser(testerUserId, "tester", "last", "TESTER");
+ // deleteAndCreateCategory(category);
+
+ String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
+ Either<UserData, TitanOperationStatus> findUser = titanDao.getNode(key, userId, UserData.class);
+ User adminUser = OperationTestsUtil.convertUserDataToUser(findUser.left().value());
+ Either<UserData, TitanOperationStatus> findTesterUser = titanDao.getNode(key, testerUserId, UserData.class);
+ User testerUser = OperationTestsUtil.convertUserDataToUser(findTesterUser.left().value());
+
+ // Create 3 new services
+ Service resultService = createService(userId, category, serviceName, "0.1", false);
+ log.debug("{}", resultService);
+ String serviceId = resultService.getUniqueId();
+ Service resultService2 = createService(userId, category, serviceName2, "0.1", false);
+ log.debug("{}", resultService2);
+ String serviceId2 = resultService2.getUniqueId();
+ Service resultService3 = createService(userId, category, serviceName3, "0.1", false);
+ log.debug("{}", resultService3);
+ String serviceId3 = resultService3.getUniqueId();
+
+ // update 1 service to READY_FOR_CERTIFICATION
+ Either<? extends Component, StorageOperationStatus> certReqResponse = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Service RFCService = (Service) certReqResponse.left().value();
+ assertEquals(RFCService.getLifecycleState(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
+
+ // update 1 service to CERTIFICATION_IN_PROGRESS
+ Either<? extends Component, StorageOperationStatus> startCertificationResponse = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService2, testerUser, adminUser, false);
+ Service IPService = (Service) startCertificationResponse.left().value();
+ assertEquals(IPService.getLifecycleState(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+
+ Set<LifecycleStateEnum> lifecycleStates = new HashSet<LifecycleStateEnum>();
+ lifecycleStates.add(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
+
+ Either<List<Service>, StorageOperationStatus> services = serviceOperation.getTesterFollowed(testerUserId,
+ lifecycleStates, false);
+
+ assertTrue(services.isLeft());
+ List<Service> result = services.left().value();
+
+ List<String> ids = new ArrayList<>();
+ for (Service service : result) {
+ ids.add(service.getUniqueId());
+ }
+ assertTrue(ids.contains(serviceId));
+ assertTrue(ids.contains(serviceId2));
+ assertFalse(ids.contains(serviceId3));
+ serviceOperation.deleteService(serviceId);
+ serviceOperation.deleteService(serviceId2);
+ serviceOperation.deleteService(serviceId3);
+
+ }
+
+ @Test
+ public void testOpsFollowed() {
+ String serviceName = "Test1";
+ String serviceName2 = "Test2";
+ String serviceName3 = "Test3";
+ String serviceName4 = "Test4";
+ String userId = USER_ID;
+ String category = CATEGORY_NAME;
+ String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
+ Either<UserData, TitanOperationStatus> findUser = titanDao.getNode(key, userId, UserData.class);
+ User adminUser = OperationTestsUtil.convertUserDataToUser(findUser.left().value());
+
+ // Create 4 new services
+ Service resultService = createService(userId, category, serviceName, "0.1", false);
+ log.debug("{}", resultService);
+ String serviceId = resultService.getUniqueId();
+ Service resultService2 = createService(userId, category, serviceName2, "0.1", false);
+ log.debug("{}", resultService2);
+ String serviceId2 = resultService2.getUniqueId();
+ Service resultService3 = createService(userId, category, serviceName3, "0.1", false);
+ log.debug("{}", resultService3);
+ String serviceId3 = resultService3.getUniqueId();
+ Service resultService4 = createService(userId, category, serviceName4, "0.1", false);
+ log.debug("{}", resultService3);
+ String serviceId4 = resultService4.getUniqueId();
+
+ // update 1 service to CERTIFIED dist status DISTRIBUTED
+ Either<? extends Component, StorageOperationStatus> reqCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Either<? extends Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Service actualService = (Service) startCertificationResult.left().value();
+
+ Either<? extends Component, StorageOperationStatus> certResponse = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Service certifiedService = (Service) certResponse.left().value();
+ serviceOperation.updateDestributionStatus(resultService, adminUser, DistributionStatusEnum.DISTRIBUTED);
+
+ // update 1 service to CERTIFIED dist status DISTRIBUTION_APPROVED
+ Either<? extends Component, StorageOperationStatus> reqCertificationResult2 = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService2, adminUser, adminUser, false);
+ Either<? extends Component, StorageOperationStatus> startCertificationResult2 = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService2, adminUser, adminUser, false);
+ Service actualService2 = (Service) startCertificationResult2.left().value();
+
+ Either<? extends Component, StorageOperationStatus> certResponse2 = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, resultService2, adminUser, adminUser, false);
+ Service certifiedService2 = (Service) certResponse2.left().value();
+ serviceOperation.updateDestributionStatus(resultService2, adminUser,
+ DistributionStatusEnum.DISTRIBUTION_APPROVED);
+
+ // update 1 service to CERTIFIED dist status DISTRIBUTION_REJECTED
+ Either<? extends Component, StorageOperationStatus> reqCertificationResult3 = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService3, adminUser, adminUser, false);
+ Either<? extends Component, StorageOperationStatus> startCertificationResult3 = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService3, adminUser, adminUser, false);
+ Service actualService3 = (Service) startCertificationResult3.left().value();
+
+ Either<? extends Component, StorageOperationStatus> certResponse3 = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, actualService3, adminUser, adminUser, false);
+ Service certifiedService3 = (Service) certResponse3.left().value();
+ serviceOperation.updateDestributionStatus(certifiedService3, adminUser,
+ DistributionStatusEnum.DISTRIBUTION_REJECTED);
+
+ Map<String, Object> propertiesToMatch = new HashMap<>();
+ propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
+
+ Set<DistributionStatusEnum> distStatus = new HashSet<DistributionStatusEnum>();
+ distStatus.add(DistributionStatusEnum.DISTRIBUTION_APPROVED);
+ distStatus.add(DistributionStatusEnum.DISTRIBUTED);
+
+ Either<Set<Service>, StorageOperationStatus> services = serviceOperation
+ .getCertifiedServicesWithDistStatus(propertiesToMatch, distStatus, false);
+
+ assertTrue(services.isLeft());
+ Set<Service> result = services.left().value();
+
+ List<String> ids = new ArrayList<>();
+ for (Service service : result) {
+ ids.add(service.getUniqueId());
+ }
+ assertTrue(ids.contains(certifiedService.getUniqueId()));
+ assertTrue(ids.contains(certifiedService2.getUniqueId()));
+ assertFalse(ids.contains(certifiedService3.getUniqueId()));
+ assertFalse(ids.contains(resultService4.getUniqueId()));
+ serviceOperation.deleteService(serviceId);
+ serviceOperation.deleteService(serviceId2);
+ serviceOperation.deleteService(serviceId3);
+ serviceOperation.deleteService(serviceId4);
+ }
+
+ @Test
+ public void testGovernorFollowed() {
+ String serviceName = "Test1";
+ String serviceName2 = "Test2";
+ String serviceName3 = "Test3";
+ String userId = USER_ID;
+ String category = CATEGORY_NAME;
+ String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
+ Either<UserData, TitanOperationStatus> findUser = titanDao.getNode(key, userId, UserData.class);
+ User adminUser = OperationTestsUtil.convertUserDataToUser(findUser.left().value());
+
+ // Create 3 new services
+ Service resultService = createService(userId, category, serviceName, "0.1", false);
+ log.debug("{}", resultService);
+ String serviceId = resultService.getUniqueId();
+ Service resultService2 = createService(userId, category, serviceName2, "0.1", false);
+ log.debug("{}", resultService2);
+ String serviceId2 = resultService2.getUniqueId();
+ Service resultService3 = createService(userId, category, serviceName3, "0.1", false);
+ log.debug("{}", resultService3);
+ String serviceId3 = resultService3.getUniqueId();
+
+ // update 1 service to CERTIFIED + DISTRIBUTED
+ Either<? extends Component, StorageOperationStatus> reqCertificationResult = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Either<? extends Component, StorageOperationStatus> startCertificationResult = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService, adminUser, adminUser, false);
+ Service actualService = (Service) startCertificationResult.left().value();
+
+ Either<? extends Component, StorageOperationStatus> certResponse = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, actualService, adminUser, adminUser, false);
+ Service certifiedService = (Service) certResponse.left().value();
+ serviceOperation.updateDestributionStatus(certifiedService, adminUser, DistributionStatusEnum.DISTRIBUTED);
+
+ // update 1 service to CERTIFIED dist status + DISTRIBUTION_REJECTED
+ Either<? extends Component, StorageOperationStatus> reqCertificationResult2 = lifecycleOperation
+ .requestCertificationComponent(NodeTypeEnum.Service, resultService2, adminUser, adminUser, false);
+ Either<? extends Component, StorageOperationStatus> startCertificationResult2 = lifecycleOperation
+ .startComponentCertification(NodeTypeEnum.Service, resultService2, adminUser, adminUser, false);
+ Service actualService2 = (Service) startCertificationResult2.left().value();
+
+ Either<? extends Component, StorageOperationStatus> certResponse2 = lifecycleOperation
+ .certifyComponent(NodeTypeEnum.Service, actualService2, adminUser, adminUser, false);
+ Service certifiedService2 = (Service) certResponse2.left().value();
+ serviceOperation.updateDestributionStatus(certifiedService2, adminUser, DistributionStatusEnum.DISTRIBUTED);
+
+ Map<String, Object> propertiesToMatch = new HashMap<>();
+ propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
+
+ Either<Set<Service>, StorageOperationStatus> services = serviceOperation
+ .getCertifiedServicesWithDistStatus(propertiesToMatch, null, false);
+
+ assertTrue(services.isLeft());
+ Set<Service> result = services.left().value();
+
+ List<String> ids = new ArrayList<>();
+ for (Service service : result) {
+ ids.add(service.getUniqueId());
+ }
+ assertTrue(ids.contains(certifiedService.getUniqueId()));
+ assertTrue(ids.contains(certifiedService2.getUniqueId()));
+ assertFalse(ids.contains(serviceId3));
+ serviceOperation.deleteService(serviceId);
+ serviceOperation.deleteService(serviceId2);
+ serviceOperation.deleteService(serviceId3);
+ }
+
+}
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
new file mode 100644
index 0000000000..f77e477ed7
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java
@@ -0,0 +1,239 @@
+/*-
+ * ============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.operations.impl;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+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;
+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.operations.impl.UserAdminOperation;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.common.api.UserRoleEnum;
+
+import fj.data.Either;
+
+public class UserAdminOperationTest extends ModelTestBase {
+ @InjectMocks
+ private static final UserAdminOperation userAdminOperation = new UserAdminOperation();
+ private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class);
+
+ private static final String ADMIN = "admin";
+
+ @BeforeClass
+ public static void setup() {
+ ModelTestBase.init();
+ }
+
+ @Before
+ public void initMocks() {
+ MockitoAnnotations.initMocks(this);
+ Mockito.reset(titanGenericDao);
+ mockTitanUpdate();
+ mockTitanDelete();
+
+ }
+
+ @Test
+ public void testDeActivateUserDataSuccess() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ Either<User, StorageOperationStatus> eitherUser = userAdminOperation
+ .deActivateUser(userAdminOperation.convertToUser(userData));
+
+ verify(titanGenericDao, times(1)).updateNode(Mockito.eq(userData), Mockito.eq(UserData.class));
+ verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ assertTrue(eitherUser.isLeft());
+ User user = eitherUser.left().value();
+ assertTrue(user.getStatus() == UserStatusEnum.INACTIVE);
+
+ }
+
+ /*
+ * @Test public void testDeActivateUserDataFail(){ UserData userData =
+ * mockTitanGet(ADMIN, UserRoleEnum.ADMIN, false);
+ *
+ * Either<User, StorageOperationStatus> eitherUser =
+ * userAdminOperation.deActivateUser(userAdminOperation.convertToUser(
+ * userData));
+ *
+ * verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class),
+ * Mockito.eq(UserData.class)); verify(titanGenericDao,
+ * times(0)).deleteNode(Mockito.any(UserData.class),
+ * Mockito.eq(UserData.class)); assertTrue(eitherUser.isRight());
+ * assertTrue(eitherUser.right().value() ==
+ * StorageOperationStatus.USER_INACTIVE);
+ *
+ * }
+ */
+
+ @Test
+ public void testDeleteUserWithoutResources() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ List<Edge> edgesList = new ArrayList<Edge>();
+
+ Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
+ when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
+
+ Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
+ verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ verify(titanGenericDao, times(1)).deleteNode(userData, UserData.class);
+ assertTrue(eitherUser.isLeft());
+
+ }
+
+ @Test
+ public void testDeleteUserWithResources() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ List<Edge> edgesList = new ArrayList<Edge>();
+ edgesList.add(getEmptyEdgeImpl());
+
+ Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
+ when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
+
+ Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
+ verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ assertTrue(eitherUser.isRight());
+ assertTrue(eitherUser.right().value() == ActionStatus.USER_HAS_ACTIVE_ELEMENTS);
+
+ }
+
+ private Edge getEmptyEdgeImpl() {
+ return new Edge() {
+
+ @Override
+ public Object id() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String label() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Graph graph() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <V> Property<V> property(String key, V value) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void remove() {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public Iterator<Vertex> vertices(Direction direction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <V> Iterator<Property<V>> properties(String... propertyKeys) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ };
+ }
+
+ private UserData mockTitanGet(String userId, UserRoleEnum role, boolean isActive) {
+ UserData userData = buildUserData(userId, role, isActive);
+ Either<UserData, TitanOperationStatus> eitherUserData = Either.left(userData);
+ when(titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class))
+ .thenReturn(eitherUserData);
+ return userData;
+ }
+
+ private static void mockTitanUpdate() {
+ doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
+ public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
+ Object[] args = invocation.getArguments();
+ UserData retValue = (UserData) args[0];
+ Either<UserData, TitanOperationStatus> result = Either.left(retValue);
+ return result;
+ }
+
+ }).when(titanGenericDao).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ }
+
+ private static void mockTitanDelete() {
+ doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
+ public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
+ Object[] args = invocation.getArguments();
+ UserData retValue = (UserData) args[0];
+ Either<UserData, TitanOperationStatus> result = Either.left(retValue);
+ return result;
+ }
+
+ }).when(titanGenericDao).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
+ }
+
+ private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setRole(role.getName());
+ userData.setStatus(isActive ? UserStatusEnum.ACTIVE.name() : UserStatusEnum.INACTIVE.name());
+ return userData;
+
+ }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/DataTypeValidatorTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/DataTypeValidatorTest.java
new file mode 100644
index 0000000000..2b9c296eb5
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/DataTypeValidatorTest.java
@@ -0,0 +1,1004 @@
+/*-
+ * ============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.operations.impl.util;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertNotNull;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.Test;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
+import org.openecomp.sdc.be.model.tosca.converters.ListConverter;
+import org.openecomp.sdc.be.model.tosca.converters.MapConverter;
+import org.openecomp.sdc.be.model.tosca.validators.DataTypeValidatorConverter;
+import org.openecomp.sdc.be.model.tosca.validators.ListValidator;
+import org.openecomp.sdc.be.model.tosca.validators.MapValidator;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.reflect.TypeToken;
+
+import fj.data.Either;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DataTypeValidatorTest {
+ private static Logger log = LoggerFactory.getLogger(DataTypeValidatorTest.class.getName());
+ private static Gson gson = new Gson();
+
+ DataTypeValidatorConverter dataTypeValidator = DataTypeValidatorConverter.getInstance();
+
+ @Test
+ public void testDerivedFromPrimitiveEmptyValue() {
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ allDataTypes.put("integer", getPrimitiveDataType("integer"));
+
+ DataTypeDefinition fromIntegerType = buildDerivedFromIntegerType();
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate("", fromIntegerType,
+ allDataTypes);
+
+ assertTrue("check result is valid", validate.right.booleanValue());
+ assertEquals("check value is the same as sent", null, validate.left);
+
+ validate = dataTypeValidator.validateAndUpdate(null, fromIntegerType, allDataTypes);
+
+ assertTrue("check result is valid", validate.right.booleanValue());
+ assertEquals("check value is the same as sent", null, validate.left);
+
+ validate = dataTypeValidator.validateAndUpdate("88", fromIntegerType, allDataTypes);
+
+ assertTrue("check result is valid", validate.right.booleanValue());
+ assertEquals("check value is the same as sent", "88", validate.left.toString());
+
+ }
+
+ @Test
+ public void testCompositeWithParameterDerivedFromPrimitiveEmptyValue() {
+
+ DataTypeDefinition derivedFromIntegerType = buildDerivedFromIntegerType();
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ allDataTypes.put("myinteger", derivedFromIntegerType);
+
+ DataTypeDefinition personDataType = buildPersonDataType();
+
+ Person person = new Person("my address", 32);
+ String json = gson.toJson(person);
+ log.debug(json);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, personDataType,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ person = new Person("my address", 32);
+ json = gson.toJson(person);
+ json = json.replace("32", "32a");
+ log.debug(json);
+
+ validate = dataTypeValidator.validateAndUpdate(json, personDataType, allDataTypes);
+ assertFalse("check valid value", validate.right.booleanValue());
+
+ }
+
+ @Test
+ public void testCompositeWithEmptyListValue() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ String[] strArr = {};
+ List<String> strList = Arrays.asList(strArr);
+
+ // Check empty list
+ Credential credential = new Credential("protcol<br>>", 5, "token_type", "token", null, "user", true, strList);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+ log.debug(json);
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ Credential credentialRes = gson.fromJson(validate.left.toString(), Credential.class);
+ assertEquals("check empty list", 0, credentialRes.getMylist().size());
+
+ log.debug("Result is = {}", validate.left.toString());
+
+ }
+
+ @Test
+ public void testCompositeWithListNullValue() {
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check list is NULL
+ Credential credential = new Credential("protcol<br>>", 5, "token_type", "token", null, "user", true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ Credential credentialRes = gson.fromJson(validate.left.toString(), Credential.class);
+ assertNull("check list is null", credentialRes.getMylist());
+ log.debug("Result is = {}", validate.left.toString());
+
+ }
+
+ @Test
+ public void testCompositeWithUserNullValue() {
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", 5, "token_type", "token", null, null, true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ Credential credentialRes = gson.fromJson(validate.left.toString(), Credential.class);
+ assertNull("check list is null", credentialRes.getUser());
+ log.debug("Result is = {}", validate.left.toString());
+ }
+
+ @Test
+ public void testCompositeWithEmptyUserValue() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+ // Check user is empty
+ Credential credential = new Credential("protcol<br>>", 5, "token_type", "token", null, "", true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+ log.debug(json);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ Credential credentialRes = gson.fromJson(validate.left.toString(), Credential.class);
+ assertNotNull("check list is not null", credentialRes.getUser());
+ assertEquals("check user is empty", "", credentialRes.getUser());
+ log.debug("Result is = {}", validate.left.toString());
+
+ }
+
+ @Test
+ public void testCompositeWithSumNullValue() {
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", null, "token_type", "token", null, null, true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ Credential credentialRes = gson.fromJson(validate.left.toString(), Credential.class);
+ assertNull("check list is null", credentialRes.getSum());
+ log.debug("Result is = {}", validate.left.toString());
+ }
+
+ @Test
+ public void testInvalidJson() {
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", null, "token_type", "token", null, null, true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ json += "fdfd";
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertFalse("check valid value", validate.right.booleanValue());
+
+ }
+
+ @Test
+ public void testInvalidInnerValue() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", null, "token_type", "token", null, null, true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ json = json.replace("55", "a55b");
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertFalse("check valid value", validate.right.booleanValue());
+
+ }
+
+ @Test
+ public void testInvalidInnerJson() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", null, "token_type", "token", null, null, true, null);
+ City mycity = new City("", null);
+
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ json = json.replace("{\"address\":\"\"}", "scalar");
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertFalse("check valid value", validate.right.booleanValue());
+
+ }
+
+ @Test
+ public void testInvalidPropertyJson() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ // Check user is null
+ Credential credential = new Credential("protcol<br>>", null, "token_type", "token", null, null, true, null);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ json = json.replace("55", "a55b");
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertFalse("check valid value", validate.right.booleanValue());
+
+ }
+
+ @Test
+ public void testCompositeDataTypeWithInternalComposite() {
+
+ DataTypeDefinition dataTypeDefinition = buildCredentialDataType();
+
+ String[] strArr = { "aaa", "bbb", "c<br>dcc" };
+ List<String> strList = Arrays.asList(strArr);
+
+ Credential credential = new Credential("protcol<br>>", 5, "token_type", "token", null, "user", true, strList);
+ City mycity = new City("myadd<br><<br>", 55);
+ credential.setMycity(mycity);
+
+ String json = gson.toJson(credential);
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ ImmutablePair<JsonElement, Boolean> validate = dataTypeValidator.validateAndUpdate(json, dataTypeDefinition,
+ allDataTypes);
+ assertTrue("check valid value", validate.right.booleanValue());
+
+ log.debug("Result is = {}", validate.left.toString());
+
+ }
+
+ @Test
+ public void testMapValidator() {
+
+ MapValidator validator = new MapValidator();
+ Gson gson = new Gson();
+ // Happy Scenarios
+ // 1 - Map<String,Integer> check OK
+ Map<String, Integer> map_1 = new HashMap<>();
+ map_1.put("key1", 2);
+ map_1.put("key2", 3);
+ String value = gson.toJson(map_1);
+ String innerType = "integer";
+ assertTrue("Test Map validation with inner integer type", validator.isValid(value, innerType, null));
+
+ // 2 - Map<String,Boolean> check OK
+ Map<String, Boolean> map_2 = new HashMap<>();
+ map_2.put("key1", true);
+ map_2.put("key2", false);
+ value = gson.toJson(map_2);
+ innerType = "boolean";
+ assertTrue("Test Map validation with inner boolean type", validator.isValid(value, innerType, null));
+
+ // 3 - give integer with quotes
+ innerType = "integer";
+ value = "{\"key1\":\"5\",\"key2\":\"7\"}";
+ assertTrue("Test Map validation with inner integer type, but qouted values",
+ validator.isValid(value, innerType, null));
+
+ // 4 - empty default value
+ innerType = "float";
+ value = "";
+ assertTrue("Test Map validation with inner float type", validator.isValid(value, innerType, null));
+
+ // Faulty Scenarios
+ // 5 - mismatch in data type
+ value = gson.toJson(map_1);
+ innerType = "boolean";
+ assertFalse("Test Map faulty validation with inner boolean type", validator.isValid(value, innerType, null));
+ // 6 - mismatch in data type
+ value = gson.toJson(map_2);
+ innerType = "integer";
+ assertFalse("Test Map faulty validation with inner integer type", validator.isValid(value, innerType, null));
+
+ }
+
+ @Test
+ public void testMapConverter() {
+
+ MapConverter converter = new MapConverter();
+ Gson gson = new Gson();
+ // Happy Scenarios
+ Map<String, String> map_1 = new HashMap<>();
+ Map<String, String> resMap_1 = new HashMap<>();
+
+ // 1 - check Spaces eliminated + html square brackets eliminated
+ map_1.put("key1", "<b>test</b>");
+ map_1.put("key2", " test");
+ resMap_1.put("key1", "test");
+ resMap_1.put("key2", " test");
+ String value = gson.toJson(map_1);
+ String expectedVal = gson.toJson(resMap_1);
+ String innerType = "string";
+ assertEquals("Test Map validation with inner string type", expectedVal,
+ converter.convert(value, innerType, null));
+
+ // 2 - float converter
+ innerType = "float";
+ value = "{\"key1\":0.4545,\"key2\":0.2f}";
+ expectedVal = "{\"key1\":0.4545,\"key2\":0.2}";
+ assertEquals("Test Map validation with inner float type", expectedVal,
+ converter.convert(value, innerType, null));
+
+ // 3 - check default empty value converter
+ innerType = "float";
+ value = "";
+ expectedVal = "";
+ assertEquals("Test Map validation with inner float type", expectedVal,
+ converter.convert(value, innerType, null));
+
+ // 4 - invalid json
+ // 3 - check default empty value converter
+ innerType = "float";
+ value = "{1345234556@#(";
+ expectedVal = null;
+ assertEquals("Test Map validation with inner float type", expectedVal,
+ converter.convert(value, innerType, null));
+
+ }
+
+ @Test
+ public void testCompositeDataTypeWithMapComposite() {
+
+ DataTypeDefinition fileDataTypeDefinition = buildFileDataType();
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+
+ MyFile myFile = new MyFile();
+ myFile.setAge(88);
+ Map<String, City> attributes = new HashMap<>();
+ attributes.put("key1", new City("address1<br>", 11));
+ attributes.put("key2", new City("address2<br>", 22));
+ myFile.setAttributes(attributes);
+
+ String str = gson.toJson(myFile);
+ log.debug(str);
+
+ ImmutablePair<JsonElement, Boolean> convert = dataTypeValidator.validateAndUpdate(str, fileDataTypeDefinition,
+ allDataTypes);
+
+ assertTrue("check map converter succeed", convert.right);
+
+ JsonElement convertedValue = convert.left;
+
+ log.debug("{}", convertedValue);
+ MyFile fromJson = gson.fromJson(convertedValue, MyFile.class);
+
+ assertEquals("check age", 88, fromJson.getAge().intValue());
+ assertEquals("check address 1", "address1", fromJson.getAttributes().get("key1").getAddress());
+ assertEquals("check address 2", "address2", fromJson.getAttributes().get("key2").getAddress());
+
+ }
+
+ @Test
+ public void testMapConverterWithComplexInnerType() {
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition credentialDataTypeDefinition = buildCredentialDataType();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+ allDataTypes.put("credential", credentialDataTypeDefinition);
+
+ Gson gson = new Gson();
+ // Happy Scenarios
+ Map<String, Object> map_1 = new HashMap<>();
+
+ // 1 - check Spaces eliminated + html square brackets eliminated
+
+ String[] strArr = { "aaa", "bbb", "c<br>dcc" };
+ List<String> strList = Arrays.asList(strArr);
+ Credential credential1 = new Credential("protocol;:,.\"<br>>", 5, "token_type", "token", null, "user", true,
+ strList);
+ City mycity1 = new City("myadd<br><<br>", 55);
+ credential1.setMycity(mycity1);
+
+ Credential credential2 = new Credential("protocol;:,.\"<br>>", 5, "token_type", "token", null, "user", true,
+ strList);
+ City mycity2 = new City("myadd<br><<br>", 66);
+ credential2.setMycity(mycity2);
+
+ map_1.put("key1", credential1);
+ map_1.put("key2", credential2);
+
+ String str = gson.toJson(map_1);
+ log.debug(str);
+
+ MapConverter mapConverter = new MapConverter();
+ Either<String, Boolean> convert = mapConverter.convertWithErrorResult(str, "credential", allDataTypes);
+
+ assertTrue("check map converter succeed", convert.isLeft());
+
+ String convertedValue = convert.left().value();
+
+ Type type = new TypeToken<Map<String, Credential>>() {
+ }.getType();
+
+ Map<String, Credential> fromJson = gson.fromJson(convertedValue, type);
+
+ Credential actualCredential1 = fromJson.get("key1");
+ assertEquals("check sum", 5, actualCredential1.getSum().intValue());
+ assertEquals("check protocol", "protocol;:,.\">", actualCredential1.getProtocol());
+ String[] convertedStrArr = { "aaa", "bbb", "cdcc" };
+ List<String> convertedStrList = Arrays.asList(convertedStrArr);
+ assertEquals("check list", convertedStrList, actualCredential1.getMylist());
+
+ assertEquals("check city address", "myadd<", actualCredential1.getMycity().getAddress());
+ assertEquals("check city address", 55, actualCredential1.getMycity().getAge().intValue());
+
+ Credential actualCredential2 = fromJson.get("key2");
+ assertEquals("check city address", 66, actualCredential2.getMycity().getAge().intValue());
+
+ }
+
+ @Test
+ public void testListConverterWithComplexInnerType() {
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition credentialDataTypeDefinition = buildCredentialDataType();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+ allDataTypes.put("credential", credentialDataTypeDefinition);
+
+ Gson gson = new Gson();
+
+ List<Object> list = buildListOf2CredentialObjects();
+
+ String str = gson.toJson(list);
+ log.debug(str);
+
+ ListConverter listConverter = new ListConverter();
+
+ Either<String, Boolean> convert = listConverter.convertWithErrorResult(str, "credential", allDataTypes);
+
+ assertTrue("check map converter succeed", convert.isLeft());
+
+ String convertedValue = convert.left().value();
+
+ validateListOfCredential(gson, convertedValue);
+
+ list.add(null);
+
+ str = gson.toJson(list);
+ log.debug(str);
+
+ convert = listConverter.convertWithErrorResult(str, "credential", allDataTypes);
+
+ assertTrue("check map converter succeed", convert.isLeft());
+
+ validateListOfCredential(gson, convertedValue);
+ }
+
+ @Test
+ public void testListValidatorWithComplexInnerType() {
+
+ Map<String, DataTypeDefinition> allDataTypes = new HashMap<String, DataTypeDefinition>();
+ DataTypeDefinition credentialDataTypeDefinition = buildCredentialDataType();
+ DataTypeDefinition cityDataType = buildCityDataType();
+ allDataTypes.put("city", cityDataType);
+ allDataTypes.put("credential", credentialDataTypeDefinition);
+
+ Gson gson = new Gson();
+ // Happy Scenarios
+ List<Object> list = buildListOf2CredentialObjects();
+
+ String str = gson.toJson(list);
+ log.debug(str);
+
+ ListValidator listValidator = new ListValidator();
+
+ boolean isValid = listValidator.isValid(str, "credential", allDataTypes);
+
+ assertTrue("check valid value", isValid);
+
+ String badStr = str.replace("protocol", "protocol1");
+
+ isValid = listValidator.isValid(badStr, "credential", allDataTypes);
+
+ assertFalse("check valid value", isValid);
+
+ badStr = str.replace("55", "\"aa\"");
+
+ isValid = listValidator.isValid(badStr, "credential", allDataTypes);
+
+ assertFalse("check valid value", isValid);
+
+ }
+
+ private List<Object> buildListOf2CredentialObjects() {
+ List<Object> list = new ArrayList<>();
+
+ String[] strArr = { "aaa", "bbb", "c<br>dcc" };
+ List<String> strList = Arrays.asList(strArr);
+ Credential credential1 = new Credential("protocol.,\":;<br>>", 5, "token_type", "token", null, "user", true,
+ strList);
+ City mycity1 = new City("myadd<br><<br>", 55);
+ credential1.setMycity(mycity1);
+
+ Credential credential2 = new Credential("protocol.,\":;<br>>", 5, "token_type", "token", null, "user", true,
+ strList);
+ City mycity2 = new City("myadd<br><<br>", 66);
+ credential2.setMycity(mycity2);
+
+ list.add(credential1);
+ list.add(credential2);
+ return list;
+ }
+
+ private void validateListOfCredential(Gson gson, String convertedValue) {
+
+ log.debug(convertedValue);
+ Type type = new TypeToken<List<Credential>>() {
+ }.getType();
+
+ List<Credential> fromJson = gson.fromJson(convertedValue, type);
+
+ assertEquals("check list size", 2, fromJson.size());
+
+ // Credential actualCredential1 = gson.fromJson(list.get(0).toString(),
+ // Credential.class);
+ Credential actualCredential1 = fromJson.get(0);
+ assertEquals("check sum", 5, actualCredential1.getSum().intValue());
+ assertEquals("check protocol", "protocol.,\":;>", actualCredential1.getProtocol());
+ String[] convertedStrArr = { "aaa", "bbb", "cdcc" };
+ List<String> convertedStrList = Arrays.asList(convertedStrArr);
+ assertEquals("check list", convertedStrList, actualCredential1.getMylist());
+
+ assertEquals("check city address", "myadd<", actualCredential1.getMycity().getAddress());
+ assertEquals("check city address", 55, actualCredential1.getMycity().getAge().intValue());
+
+ // Credential actualCredential2 = gson.fromJson(list.get(1).toString(),
+ // Credential.class);
+ Credential actualCredential2 = fromJson.get(1);
+ assertEquals("check city address", 66, actualCredential2.getMycity().getAge().intValue());
+ }
+
+ private DataTypeDefinition buildCredentialDataType() {
+ DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName("datatype.1");
+ List<PropertyDefinition> properties = new ArrayList<>();
+ PropertyDefinition propertyDefinition1 = new PropertyDefinition();
+ propertyDefinition1.setName("sum");
+ propertyDefinition1.setType(ToscaPropertyType.INTEGER.getType());
+ PropertyDefinition propertyDefinition2 = new PropertyDefinition();
+ propertyDefinition2.setName("protocol");
+ propertyDefinition2.setType(ToscaPropertyType.STRING.getType());
+ PropertyDefinition propertyDefinition3 = new PropertyDefinition();
+ propertyDefinition3.setName("token_type");
+ propertyDefinition3.setType(ToscaPropertyType.STRING.getType());
+ PropertyDefinition propertyDefinition4 = new PropertyDefinition();
+ propertyDefinition4.setName("token");
+ propertyDefinition4.setType(ToscaPropertyType.STRING.getType());
+ PropertyDefinition propertyDefinition5 = new PropertyDefinition();
+ propertyDefinition5.setName("keys");
+ propertyDefinition5.setType(ToscaPropertyType.MAP.getType());
+ PropertyDefinition propertyDefinition6 = new PropertyDefinition();
+ propertyDefinition6.setName("mylist");
+ propertyDefinition6.setType(ToscaPropertyType.LIST.getType());
+ SchemaDefinition entrySchema = new SchemaDefinition();
+ PropertyDataDefinition property = new PropertyDataDefinition();
+ property.setType("string");
+ entrySchema.setProperty(property);
+ propertyDefinition6.setSchema(entrySchema);
+ PropertyDefinition propertyDefinition7 = new PropertyDefinition();
+ propertyDefinition7.setName("user");
+ propertyDefinition7.setType(ToscaPropertyType.STRING.getType());
+ PropertyDefinition propertyDefinition8 = new PropertyDefinition();
+ propertyDefinition8.setName("isMandatory");
+ propertyDefinition8.setType(ToscaPropertyType.BOOLEAN.getType());
+
+ PropertyDefinition propertyDefinition9 = new PropertyDefinition();
+ propertyDefinition9.setName("mycity");
+ propertyDefinition9.setType("city");
+
+ properties.add(propertyDefinition1);
+ properties.add(propertyDefinition2);
+ properties.add(propertyDefinition3);
+ properties.add(propertyDefinition4);
+ properties.add(propertyDefinition5);
+ properties.add(propertyDefinition6);
+ properties.add(propertyDefinition7);
+ properties.add(propertyDefinition8);
+ properties.add(propertyDefinition9);
+
+ dataTypeDefinition.setProperties(properties);
+ return dataTypeDefinition;
+ }
+
+ private static DataTypeDefinition buildCityDataType() {
+ DataTypeDefinition cityDataType = new DataTypeDefinition();
+ cityDataType.setName("city");
+ List<PropertyDefinition> cityProperties = new ArrayList<>();
+ PropertyDefinition cityPropertyDefinition1 = new PropertyDefinition();
+ cityPropertyDefinition1.setName("age");
+ cityPropertyDefinition1.setType(ToscaPropertyType.INTEGER.getType());
+ PropertyDefinition cityPropertyDefinition2 = new PropertyDefinition();
+ cityPropertyDefinition2.setName("address");
+ cityPropertyDefinition2.setType(ToscaPropertyType.STRING.getType());
+
+ cityProperties.add(cityPropertyDefinition1);
+ cityProperties.add(cityPropertyDefinition2);
+
+ cityDataType.setProperties(cityProperties);
+ return cityDataType;
+ }
+
+ private static DataTypeDefinition buildPersonDataType() {
+ DataTypeDefinition personDataType = new DataTypeDefinition();
+ personDataType.setName("person");
+ List<PropertyDefinition> personProperties = new ArrayList<>();
+ PropertyDefinition personPropertyDefinition1 = new PropertyDefinition();
+ personPropertyDefinition1.setName("age");
+ personPropertyDefinition1.setType("myinteger");
+ PropertyDefinition personPropertyDefinition2 = new PropertyDefinition();
+ personPropertyDefinition2.setName("address");
+ personPropertyDefinition2.setType(ToscaPropertyType.STRING.getType());
+
+ personProperties.add(personPropertyDefinition1);
+ personProperties.add(personPropertyDefinition2);
+
+ personDataType.setProperties(personProperties);
+ return personDataType;
+ }
+
+ private static DataTypeDefinition buildFileDataType() {
+ DataTypeDefinition fileDataType = new DataTypeDefinition();
+ fileDataType.setName("file");
+ List<PropertyDefinition> fileProperties = new ArrayList<>();
+ PropertyDefinition filePropertyDefinition1 = new PropertyDefinition();
+ filePropertyDefinition1.setName("age");
+ filePropertyDefinition1.setType("integer");
+
+ PropertyDefinition filePropertyDefinition2 = new PropertyDefinition();
+ filePropertyDefinition2.setName("attributes");
+ filePropertyDefinition2.setType(ToscaPropertyType.MAP.getType());
+
+ fileProperties.add(filePropertyDefinition1);
+ fileProperties.add(filePropertyDefinition2);
+
+ SchemaDefinition entrySchema = new SchemaDefinition();
+ PropertyDataDefinition property = new PropertyDataDefinition();
+ property.setType("city");
+ entrySchema.setProperty(property);
+ filePropertyDefinition2.setSchema(entrySchema);
+
+ fileDataType.setProperties(fileProperties);
+ return fileDataType;
+ }
+
+ private static DataTypeDefinition getPrimitiveDataType(String type) {
+
+ DataTypeDefinition derivedFrom = new DataTypeDefinition();
+ derivedFrom.setName(type);
+
+ return derivedFrom;
+
+ }
+
+ private static DataTypeDefinition buildDerivedFromIntegerType() {
+
+ DataTypeDefinition derivedFrom = getPrimitiveDataType("integer");
+
+ DataTypeDefinition myIntegerDataType = new DataTypeDefinition();
+ myIntegerDataType.setDerivedFrom(derivedFrom);
+
+ myIntegerDataType.setName("myinteger");
+
+ return myIntegerDataType;
+ }
+
+ public static class MyFile {
+
+ Integer age;
+
+ Map<String, City> attributes;
+
+ public Integer getAge() {
+ return age;
+ }
+
+ public void setAge(Integer age) {
+ this.age = age;
+ }
+
+ public Map<String, City> getAttributes() {
+ return attributes;
+ }
+
+ public void setAttributes(Map<String, City> attributes) {
+ this.attributes = attributes;
+ }
+
+ }
+
+ public static class City {
+
+ String address;
+ Integer age;
+
+ public City(String address, Integer age) {
+ super();
+ this.address = address;
+ this.age = age;
+ }
+
+ public String getAddress() {
+ return address;
+ }
+
+ public void setAddress(String address) {
+ this.address = address;
+ }
+
+ public Integer getAge() {
+ return age;
+ }
+
+ public void setAge(Integer age) {
+ this.age = age;
+ }
+
+ }
+
+ public static class Person {
+
+ String address;
+ Integer age;
+
+ public Person(String address, Integer age) {
+ super();
+ this.address = address;
+ this.age = age;
+ }
+
+ public String getAddress() {
+ return address;
+ }
+
+ public void setAddress(String address) {
+ this.address = address;
+ }
+
+ public Integer getAge() {
+ return age;
+ }
+
+ public void setAge(Integer age) {
+ this.age = age;
+ }
+
+ @Override
+ public String toString() {
+ return "Person [address=" + address + ", age=" + age + "]";
+ }
+
+ }
+
+ public static class Credential {
+
+ String protocol;
+ Integer sum;
+ String token_type;
+ String token;
+ Map<String, String> keys;
+ String user;
+ Boolean isMandatory;
+ List<String> mylist;
+ City mycity;
+
+ public Credential(String protocol, Integer sum, String token_type, String token, Map<String, String> keys,
+ String user, Boolean isMandatory, List<String> mylist) {
+ super();
+ this.protocol = protocol;
+ this.sum = sum;
+ this.token_type = token_type;
+ this.token = token;
+ this.keys = keys;
+ this.user = user;
+ this.isMandatory = isMandatory;
+ this.mylist = mylist;
+ }
+
+ public String getProtocol() {
+ return protocol;
+ }
+
+ public void setProtocol(String protocol) {
+ this.protocol = protocol;
+ }
+
+ public String getToken_type() {
+ return token_type;
+ }
+
+ public void setToken_type(String token_type) {
+ this.token_type = token_type;
+ }
+
+ public String getToken() {
+ return token;
+ }
+
+ public void setToken(String token) {
+ this.token = token;
+ }
+
+ public Map<String, String> getKeys() {
+ return keys;
+ }
+
+ public void setKeys(Map<String, String> keys) {
+ this.keys = keys;
+ }
+
+ public String getUser() {
+ return user;
+ }
+
+ public void setUser(String user) {
+ this.user = user;
+ }
+
+ public Boolean getIsMandatory() {
+ return isMandatory;
+ }
+
+ public void setIsMandatory(Boolean isMandatory) {
+ this.isMandatory = isMandatory;
+ }
+
+ public Integer getSum() {
+ return sum;
+ }
+
+ public void setSum(Integer sum) {
+ this.sum = sum;
+ }
+
+ public List<String> getMylist() {
+ return mylist;
+ }
+
+ public void setMylist(List<String> mylist) {
+ this.mylist = mylist;
+ }
+
+ public City getMycity() {
+ return mycity;
+ }
+
+ public void setMycity(City mycity) {
+ this.mycity = mycity;
+ }
+
+ @Override
+ public String toString() {
+ return "Credential [protocol=" + protocol + ", token_type=" + token_type + ", token=" + token + ", keys="
+ + keys + ", user=" + user + ", isMandatory=" + isMandatory + "]";
+ }
+
+ }
+
+}
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
new file mode 100644
index 0000000000..e356b49a10
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/OperationTestsUtil.java
@@ -0,0 +1,95 @@
+/*-
+ * ============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.operations.impl.util;
+
+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;
+import org.openecomp.sdc.be.resources.data.ResourceCategoryData;
+import org.openecomp.sdc.be.resources.data.ServiceCategoryData;
+import org.openecomp.sdc.be.resources.data.UserData;
+import org.openecomp.sdc.be.resources.data.category.CategoryData;
+import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
+import org.openecomp.sdc.common.util.ValidationUtils;
+
+import fj.data.Either;
+
+public class OperationTestsUtil {
+
+ public static String deleteAndCreateServiceCategory(String category, TitanGenericDao titanDao) {
+ 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<CategoryData, TitanOperationStatus> createNode = titanDao.createNode(categoryData, CategoryData.class);
+ return (String) createNode.left().value().getUniqueId();
+ }
+
+ public static String deleteAndCreateResourceCategory(String category, String subcategory,
+ TitanGenericDao titanDao) {
+
+ CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceNewCategory);
+ categoryData.getCategoryDataDefinition().setName(category);
+ categoryData.getCategoryDataDefinition()
+ .setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(category));
+ categoryData.getCategoryDataDefinition().setUniqueId(UniqueIdBuilder.buildCategoryUid(
+ ValidationUtils.normalizeCategoryName4Uniqueness(category), NodeTypeEnum.ResourceNewCategory));
+
+ SubCategoryData subcategoryData = new SubCategoryData(NodeTypeEnum.ResourceSubcategory);
+ subcategoryData.getSubCategoryDataDefinition().setName(subcategory);
+ subcategoryData.getSubCategoryDataDefinition()
+ .setNormalizedName(ValidationUtils.normalizeCategoryName4Uniqueness(subcategory));
+ subcategoryData.getSubCategoryDataDefinition().setUniqueId(UniqueIdBuilder
+ .buildSubCategoryUid(categoryData.getCategoryDataDefinition().getUniqueId(), subcategory));
+ titanDao.deleteNode(categoryData, CategoryData.class);
+ titanDao.deleteNode(subcategoryData, SubCategoryData.class);
+ Either<CategoryData, TitanOperationStatus> createNode = titanDao.createNode(categoryData, CategoryData.class);
+ titanDao.createNode(subcategoryData, SubCategoryData.class);
+ titanDao.createRelation(categoryData, subcategoryData, GraphEdgeLabels.SUB_CATEGORY, null);
+ return (String) createNode.left().value().getUniqueId();
+ }
+
+ public static void deleteServiceCategory(String category, TitanGenericDao titanDao) {
+ ServiceCategoryData categoryData = new ServiceCategoryData(category);
+ titanDao.deleteNode(categoryData, ServiceCategoryData.class);
+ }
+
+ public static void deleteResourceCategory(String category, String subcategory, TitanGenericDao titanDao) {
+ ResourceCategoryData categoryData = new ResourceCategoryData(category, subcategory);
+ titanDao.deleteNode(categoryData, ResourceCategoryData.class);
+ }
+
+ public static User convertUserDataToUser(UserData modifierData) {
+ User modifier = new User();
+ modifier.setUserId(modifierData.getUserId());
+ modifier.setEmail(modifierData.getEmail());
+ modifier.setFirstName(modifierData.getFirstName());
+ modifier.setLastName(modifierData.getLastName());
+ modifier.setRole(modifierData.getRole());
+ return modifier;
+ }
+}
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
new file mode 100644
index 0000000000..b58ce5598d
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/PrintGraph.java
@@ -0,0 +1,461 @@
+/*-
+ * ============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.operations.impl.util;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+
+import com.thinkaurelius.titan.core.TitanEdge;
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+//import com.tinkerpop.blueprints.Direction;
+//import com.tinkerpop.blueprints.Edge;
+//import com.tinkerpop.blueprints.Vertex;
+//import com.tinkerpop.blueprints.util.ElementHelper;
+
+public class PrintGraph {
+
+ public void printGraphVertices(TitanGraph graph) {
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ Vertex vertex = iterator.next();
+
+ // System.out.println(vertex);
+ // System.out.println(ElementHelper.getProperties(vertex));
+ // System.out.println("=======================================");
+ }
+
+ }
+ // graph.commit();
+ graph.tx().commit();
+ }
+
+ public void printGraphEdges(TitanGraph graph) {
+
+ Iterable<TitanEdge> vertices = graph.query().edges();
+
+ if (vertices != null) {
+ Iterator<TitanEdge> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ Edge edge = iterator.next();
+
+ // System.out.println(edge);
+ // System.out.println("edge=" + edge.getLabel() + ",
+ // properties="+ ElementHelper.getProperties(edge));
+ // System.out.println("edge=" + edge.label() + ", properties="+
+ // getProperties(edge));
+ // System.out.println("=======================================");
+ }
+
+ }
+ // graph.commit();
+ graph.tx().commit();
+ }
+
+ public String buildGraphForWebgraphWiz(TitanGraph graph) {
+
+ StringBuilder builder = new StringBuilder();
+ builder.append("digraph finite_state_machine {\n");
+ builder.append("rankdir=LR;\n");
+ builder.append("size=\"15,10\" \n");
+ // node [shape = doublecircle]; LR_0 LR_3 LR_4 LR_8;
+ // node [shape = circle];
+
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ Vertex vertex = iterator.next();
+
+ // System.out.println(vertex);
+ // System.out.println(ElementHelper.getProperties(vertex));
+ // System.out.println(getProperties(vertex));
+ // System.out.println("=======================================");
+
+ Map<String, Object> properties = getProperties(vertex);
+
+ String nodeLabel = (String) properties.get(GraphPropertiesDictionary.LABEL.getProperty());
+
+ String color = getColorByNodeType(nodeLabel);
+
+ String uid = getNodeIdByLabel(nodeLabel, properties);
+
+ // System.out.println("uid=" + uid);
+
+ String nodeRecord = buildNodeRecord(uid, color, properties);
+
+ // System.out.println(nodeRecord);
+
+ builder.append(nodeRecord);
+
+ // if (nodeLabel.equals(NodeTypeEnum.Category)) {
+ //
+ // String
+ //
+ // } else (nodeLabel.equals(NodeTypeEnum.User)) {
+ //
+ // }
+
+ }
+
+ }
+
+ Iterable<TitanEdge> edges = graph.query().edges();
+
+ if (edges != null) {
+ Iterator<TitanEdge> iterator = edges.iterator();
+ while (iterator.hasNext()) {
+ Edge edge = iterator.next();
+
+ // Vertex vertexFrom = edge.getVertex(Direction.OUT);
+ // Vertex vertexTo = edge.getVertex(Direction.IN);
+ Vertex vertexFrom = edge.outVertex();
+ Vertex vertexTo = edge.inVertex();
+
+ // String fromUid =
+ // getNodeIdByLabel((String)vertexFrom.getProperty(GraphPropertiesDictionary.LABEL.getProperty()),
+ // ElementHelper.getProperties(vertexFrom));
+ // String toUid =
+ // getNodeIdByLabel((String)vertexTo.getProperty(GraphPropertiesDictionary.LABEL.getProperty()),
+ // ElementHelper.getProperties(vertexTo));
+ String fromUid = getNodeIdByLabel(vertexFrom.value(GraphPropertiesDictionary.LABEL.getProperty()),
+ getProperties(vertexFrom));
+ String toUid = getNodeIdByLabel(vertexTo.value(GraphPropertiesDictionary.LABEL.getProperty()),
+ getProperties(vertexTo));
+
+ // String edgeLabel = edge.getLabel();
+ String edgeLabel = edge.label();
+
+ // String edgeRecord = buildEdgeRecord(fromUid, toUid,
+ // edgeLabel, ElementHelper.getProperties(edge));
+ String edgeRecord = buildEdgeRecord(fromUid, toUid, edgeLabel, getProperties(edge));
+
+ builder.append(edgeRecord);
+
+ // System.out.println(edge);
+ // System.out.println("edge=" + edge.getLabel() + ",
+ // properties="
+ // + ElementHelper.getProperties(edge));
+ // System.out.println("edge=" + edge.label() + ", properties="
+ // + getProperties(edge));
+ // System.out.println("=======================================");
+ }
+
+ }
+
+ builder.append(" } ");
+
+ return builder.toString();
+
+ }
+
+ // LR_0 [ style = "bold" color = "red" shape = "Mrecord" label =
+ // "hello&#92;nworld | { name | apache } | { version | 1.0 } | { uid |
+ // apache.1.0 } | { state| CERTIFIED } |{ b |{c|<here> d|e}| f}| g | h"
+ // ]
+
+ // LR_0 -> LR_2 [ label = "SS(B)" ];
+ // LR_0 -> LR_1 [ label = "SS(S)" ];
+ // LR_1 -> LR_3 [ label = "S($end)" ];
+ // LR_2 -> LR_6 [ label = "SS(b)" ];
+ // LR_2 -> LR_5 [ label = "SS(a)" ];
+ // LR_2 -> LR_4 [ label = "S(A)" ];
+ // LR_5 -> LR_7 [ label = "S(b)" ];
+ // LR_5 -> LR_5 [ label = "S(a)" ];
+ // LR_6 -> LR_6 [ label = "S(b)" ];
+ // LR_6 -> LR_5 [ label = "S(a)" ];
+ // LR_7 -> LR_8 [ label = "S(b)" ];
+ // LR_7 -> LR_5 [ label = "S(a)" ];
+ // LR_8 -> LR_6 [ label = "S(b)" ];
+ // LR_8 -> LR_5 [ label = "S(a)" ];
+
+ private String buildEdgeRecord(String fromUid, String toUid, String edgeLabel, Map<String, Object> properties) {
+
+ StringBuilder builder = new StringBuilder();
+ // LR_0 -> LR_2 [ label = "SS(B)" ];
+
+ String generatedProps = generateStringFromProperties(properties);
+
+ String color = getEdgeColorByLabel(edgeLabel);
+
+ builder.append("\"" + fromUid + "\"" + " -> " + "\"" + toUid + "\"" + " [ color = " + color + " label = \""
+ + edgeLabel + "(" + generatedProps + ")\"" + " ] " + "\n");
+
+ return builder.toString();
+ }
+
+ private String getEdgeColorByLabel(String edgeLabel) {
+
+ GraphEdgeLabels edgeLabelEnum = GraphEdgeLabels.getByName(edgeLabel);
+
+ String color = "black";
+
+ switch (edgeLabelEnum) {
+ case PROPERTY:
+ color = "orange";
+ break;
+ case CAPABILITY:
+ break;
+ case DERIVED_FROM:
+ color = "red";
+ default:
+ break;
+ }
+
+ return color;
+ }
+
+ private String generateStringFromProperties(Map<String, Object> properties) {
+
+ StringBuilder builder = new StringBuilder();
+
+ if (properties != null) {
+ for (Entry<String, Object> entry : properties.entrySet()) {
+ String key = entry.getKey();
+ String value = entry.getValue().toString();
+ builder.append(key + "=" + value + "__");
+ }
+ }
+ return builder.toString();
+
+ }
+
+ private String buildNodeRecord(String uid, String color, Map<String, Object> properties) {
+
+ StringBuilder builder = new StringBuilder();
+
+ builder.append("\"" + uid + "\"" + " [ ");
+ builder.append("style = \"bold\" ");
+ builder.append(" color = \"" + color + "\"");
+ builder.append("shape = \"Mrecord\" ");
+
+ String label = "";
+ int maxKeyLength = 0;
+ for (Entry<String, Object> entry1 : properties.entrySet()) {
+ String key = entry1.getKey();
+ int keyLength = key.length();
+ if (keyLength > maxKeyLength) {
+ maxKeyLength = keyLength;
+ }
+ }
+
+ boolean first = true;
+ for (Entry<String, Object> entry : properties.entrySet()) {
+
+ String key = entry.getKey();
+ String value = entry.getValue().toString();
+
+ if (key.equals(GraphPropertiesDictionary.CONSTRAINTS.getProperty())) {
+ value = value.replaceAll("[^\\w\\s]", "_");
+ }
+
+ key = padKey(key, maxKeyLength);
+
+ if (first) {
+ first = false;
+ } else {
+ label += " | ";
+ }
+ label += " { " + key + " | " + value + " } ";
+ }
+
+ builder.append("label = \"" + label + "\" ");
+ builder.append(" ] ");
+
+ // LR_0 [ style = "bold" color = "red" shape = "Mrecord" label =
+ // "hello&#92;nworld | { name | apache } | { version | 1.0 } | { uid |
+ // apache.1.0 } | { state| CERTIFIED } |{ b |{c|<here> d|e}| f}| g | h"
+ // ]
+
+ builder.append(" \n ");
+ return builder.toString();
+ }
+
+ private String getNodeIdByLabel(String nodeLabel, Map<String, Object> properties) {
+
+ NodeTypeEnum typeEnum = NodeTypeEnum.getByName(nodeLabel);
+
+ String uid = null;
+ switch (typeEnum) {
+
+ case User:
+ uid = (String) properties.get(GraphPropertiesDictionary.USER_ID.getProperty());
+ break;
+ case ServiceCategory:
+ case ResourceCategory:
+ case Tag:
+ uid = (String) properties.get(GraphPropertiesDictionary.NAME.getProperty());
+ break;
+
+ default:
+ uid = (String) properties.get(GraphPropertiesDictionary.UNIQUE_ID.getProperty());
+ break;
+ }
+
+ return uid;
+ }
+
+ private String getColorByNodeType(String nodeLabel) {
+
+ NodeTypeEnum typeEnum = NodeTypeEnum.getByName(nodeLabel);
+
+ String color = "red";
+ switch (typeEnum) {
+ case ServiceCategory:
+ color = "blue";
+ break;
+ case ResourceCategory:
+ color = "blue";
+ break;
+ case Resource:
+ color = "forestgreen";
+ break;
+ case User:
+ color = "green";
+ break;
+ case Capability:
+ color = "lightgreen";
+ break;
+ case CapabilityType:
+ color = "gray";
+ break;
+ case Property:
+ color = "cyan";
+ break;
+ case RelationshipType:
+ color = "darkorchid";
+ break;
+ case Requirement:
+ color = "gold";
+ break;
+ case RequirementImpl:
+ // color = "forestgreen";
+ color = "gold";
+ break;
+ case Service:
+ color = "cyan4";
+ break;
+ case Tag:
+ color = "dimgrey";
+ break;
+ default:
+ break;
+
+ }
+
+ return color;
+ }
+
+ private String padKey(String key, int maxKeyLength) {
+
+ int len = key.length();
+ for (int i = len; i < maxKeyLength; i++) {
+ key += " ";
+ }
+
+ return key;
+ }
+
+ public int getNumberOfVertices(TitanGraph graph) {
+ int counter = 0;
+ Iterable<TitanVertex> vertices = graph.query().vertices();
+
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ Vertex vertex = iterator.next();
+ counter++;
+ }
+ }
+ return counter;
+ }
+
+ public Set<String> getVerticesSet(TitanGraph titanGraph) {
+
+ Set<String> set = new HashSet<String>();
+
+ Iterable<TitanVertex> vertices = titanGraph.query().vertices();
+
+ if (vertices != null) {
+ Iterator<TitanVertex> iterator = vertices.iterator();
+ while (iterator.hasNext()) {
+ Vertex vertex = iterator.next();
+
+ // System.out.println(vertex);
+ // System.out.println(ElementHelper.getProperties(vertex));
+ // System.out.println(getProperties(vertex));
+ // System.out.println("=======================================");
+
+ // Map<String, Object> properties =
+ // ElementHelper.getProperties(vertex);
+ Map<String, Object> properties = getProperties(vertex);
+
+ String nodeLabel = (String) properties.get(GraphPropertiesDictionary.LABEL.getProperty());
+
+ String uid = getNodeIdByLabel(nodeLabel, properties);
+
+ set.add(uid);
+ }
+ }
+
+ return set;
+
+ }
+
+ public Map<String, Object> getProperties(Element element) {
+
+ Map<String, Object> result = null;
+
+ if (element.keys() != null && element.keys().size() > 0) {
+ Map<String, Property> propertyMap = ElementHelper.propertyMap(element,
+ element.keys().toArray(new String[element.keys().size()]));
+ result = new HashMap<String, Object>();
+
+ for (Entry<String, Property> entry : propertyMap.entrySet()) {
+ String key = entry.getKey();
+ Object value = entry.getValue().value();
+
+ result.put(key, value);
+ }
+ }
+ return result;
+ }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/ResourceCreationUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/ResourceCreationUtils.java
new file mode 100644
index 0000000000..b6b951bdc4
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/util/ResourceCreationUtils.java
@@ -0,0 +1,36 @@
+/*-
+ * ============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.operations.impl.util;
+
+public class ResourceCreationUtils {
+
+ public static String ATT_UID = "jm007a";
+ public static String FIRST_NAME = "Julia";
+ public static String LAST_NAME = "Hendrix";
+ public static String DEFAULT_RESOURCE_NAME = "my-resource";
+ public static String DEFAULT_RESOURCE_VERSION = "1.0";
+ public static String DEFAULT_USER_ID = "jh0003";
+
+ public static String MODIFIER_ATT_UID = "jk9990";
+ public static String MODIFIER_FIRST_NAME = "Roki";
+ public static String MODIFIER_LAST_NAME = "Balaboa";
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/serialize/TestResourceSerialization.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/serialize/TestResourceSerialization.java
new file mode 100644
index 0000000000..699e23affd
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/serialize/TestResourceSerialization.java
@@ -0,0 +1,222 @@
+/*-
+ * ============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.serialize;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.common.util.SerializationUtils;
+
+import fj.data.Either;
+
+public class TestResourceSerialization {
+
+ // @Test
+ public void findAllClassesUsedByResource() {
+
+ Set<Class> classesWithoutSerialzable = new HashSet<>();
+ Set<String> classestoIgnore = new HashSet<>();
+ classestoIgnore.add("java.util.List");
+ classestoIgnore.add("java.util.Map");
+ classestoIgnore.add("long");
+
+ Set<Class> allClasses = new HashSet<>();
+ findAllClassesUsedByResource(Resource.class, allClasses);
+ ArrayList l;
+ for (Class clazz : allClasses) {
+ Class[] interfaces = clazz.getInterfaces();
+ if (interfaces != null) {
+ String collect = Arrays.stream(interfaces).map(p -> p.getName()).collect(Collectors.joining("\n"));
+
+ Class orElse = Arrays.stream(interfaces).filter(p -> p.getName().equals("java.io.Serializable"))
+ .findAny().orElse(null);
+ if (orElse == null) {
+ classesWithoutSerialzable.add(clazz);
+ }
+
+ }
+ }
+
+ List<Class> collect = classesWithoutSerialzable.stream()
+ .filter(p -> false == classestoIgnore.contains(p.getName())).collect(Collectors.toList());
+
+ if (collect != null) {
+ System.out.println(collect.stream().map(p -> p.getName()).collect(Collectors.joining("\n")));
+ assertEquals("check all classes implements Serializable", 0, collect.size());
+ }
+
+ }
+
+ public void findAllClassesUsedByResource(Class clazz, Set<Class> allClasses) {
+
+ Class superclass = clazz.getSuperclass();
+ findAllClassesOfClass(clazz, allClasses);
+
+ if (superclass != null) {
+ findAllClassesOfClass(superclass, allClasses);
+ }
+
+ }
+
+ public void findAllClassesOfClass(Class clazz, Set<Class> allClasses) {
+
+ Field[] fields = clazz.getDeclaredFields();
+ if (fields != null) {
+ for (Field field : fields) {
+ String name = field.getName();
+ Class type = field.getType();
+
+ if (type.toString().contains(".List")) {
+ ParameterizedType stringListType = (ParameterizedType) field.getGenericType();
+ Class<?> stringListClass = (Class<?>) stringListType.getActualTypeArguments()[0];
+ // System.out.println(stringListClass); // class
+ // java.lang.String.
+ allClasses.add(stringListClass);
+ }
+
+ if (type.toString().contains("java.util.Map")) {
+ ParameterizedType stringListType = (ParameterizedType) field.getGenericType();
+
+ Type[] actualTypeArguments = stringListType.getActualTypeArguments();
+ if (actualTypeArguments != null) {
+ for (Type actualType : actualTypeArguments) {
+
+ String typeName = actualType.getTypeName();
+ // System.out.println("field " + name + "," +
+ // typeName);
+
+ if (typeName.startsWith("java.util.List<")) {
+ String internalClass = typeName.replace("java.util.List<", "").replace(">", "");
+ // create class from string
+ Class myClass;
+ try {
+ myClass = Class.forName(internalClass);
+ allClasses.add(myClass);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ assertTrue("Failed to convert " + internalClass + " to class", false);
+ }
+
+ } else {
+ try {
+ Class myClass = Class.forName(typeName);
+ allClasses.add(myClass);
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ assertTrue("Failed to convert " + typeName + " to class", false);
+ }
+
+ }
+ }
+ }
+
+ }
+
+ // System.out.println(type);
+ allClasses.add(type);
+ }
+ }
+
+ }
+
+ private void addInternalTypeOfList(Class clazz) {
+
+ // clazz.
+ // ParameterizedType stringListType = (ParameterizedType)
+ // field.getGenericType();
+ // Class<?> stringListClass = (Class<?>)
+ // stringListType.getActualTypeArguments()[0];
+ // //System.out.println(stringListClass); // class java.lang.String.
+ // allClasses.add(stringListClass);
+ //
+ }
+
+ private boolean isClassImplementedSerialize(Class clazz) {
+
+ Type[] genericInterfaces = clazz.getGenericInterfaces();
+ if (genericInterfaces != null) {
+ Type orElse = Arrays.stream(genericInterfaces).filter(p -> p.getTypeName().equals("java.io.Serializable"))
+ .findAny().orElse(null);
+ if (orElse != null) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // @Test
+ public void testSimpleResourceSerialize() {
+
+ Resource resource = new Resource();
+ String name = "res1";
+ Map<String, String> allVersions = new HashMap<String, String>();
+ allVersions.put("keya", "valuea");
+
+ resource.setName(name);
+ // all versions
+ resource.setAllVersions(allVersions);
+ List<ComponentInstance> resourceInstances = new ArrayList<ComponentInstance>();
+ // component instances
+ ComponentInstance componentInstance = new ComponentInstance();
+ componentInstance.setDescription("desc1");
+ componentInstance.setComponentUid("comUid");
+ resourceInstances.add(componentInstance);
+
+ resource.setComponentInstances(resourceInstances);
+
+ Either<byte[], Boolean> serialize = SerializationUtils.serialize(resource);
+ assertTrue("check object serialized", serialize.isLeft());
+ byte[] value = serialize.left().value();
+
+ Either<Object, Boolean> deserialize = SerializationUtils.deserialize(value);
+ assertTrue("check object deserialized", deserialize.isLeft());
+ Object obj = deserialize.left().value();
+ Resource desResource = (Resource) obj;
+ assertEquals("check name", name, desResource.getName());
+ verifyAllVersions(desResource);
+
+ }
+
+ private void verifyAllVersions(Resource desResource) {
+ assertNotNull("check all versions", desResource.getAllVersions());
+ assertEquals("check all version size", 1, desResource.getAllVersions().size());
+ assertEquals("check all version key", "keya", desResource.getAllVersions().keySet().iterator().next());
+ assertEquals("check all version value", "valuea", desResource.getAllVersions().values().iterator().next());
+ }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/IntegerValidatorTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/IntegerValidatorTest.java
new file mode 100644
index 0000000000..2dfe9a8de7
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/IntegerValidatorTest.java
@@ -0,0 +1,75 @@
+/*-
+ * ============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.tosca.validators;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertNotNull;
+import javax.validation.constraints.AssertTrue;
+
+import org.junit.Test;
+import org.openecomp.sdc.be.model.tosca.validators.IntegerValidator;
+
+public class IntegerValidatorTest {
+ private static IntegerValidator validator = IntegerValidator.getInstance();
+
+ @Test
+ public void testIntegerValidatorDecimal() {
+ assertTrue(validator.isValid(null, null));
+ assertTrue(validator.isValid("", null));
+ assertTrue(validator.isValid("0", null));
+ assertTrue(validator.isValid("+0", null));
+ assertTrue(validator.isValid("-0", null));
+ assertTrue(validator.isValid("+65465", null));
+ assertTrue(validator.isValid("-65465", null));
+ assertTrue(validator.isValid("2147483647", null));
+ assertFalse(validator.isValid("2147483648", null));
+ assertTrue(validator.isValid("-2147483648", null));
+ assertFalse(validator.isValid("-2147483649", null));
+ }
+
+ @Test
+ public void testIntegerValidatorHexa() {
+ assertTrue(validator.isValid("-0xadc", null));
+ assertTrue(validator.isValid("+0xadf", null));
+ assertTrue(validator.isValid("0x7FFFFFFF", null));
+ assertFalse(validator.isValid("0x80000000", null));
+ assertTrue(validator.isValid("-0x80000000", null));
+ assertFalse(validator.isValid("-0x80000001", null));
+ }
+
+ public void testIntegerValidatorOctal() {
+ assertTrue(validator.isValid("0o545435", null));
+ assertTrue(validator.isValid("-0o545435", null));
+ assertTrue(validator.isValid("0o17777777777", null));
+ assertFalse(validator.isValid("0o20000000000", null));
+ assertTrue(validator.isValid("-0o20000000000", null));
+ assertFalse(validator.isValid("-0o20000000001", null));
+ }
+
+ @Test
+ public void testIntegerValidatorIncorrect() {
+ assertFalse(validator.isValid("-2.147483649", null));
+ assertFalse(validator.isValid("dsfasf342342", null));
+ }
+}