Initial OpenECOMP SDC commit

Change-Id: I0924d5a6ae9cdc161ae17c68d3689a30d10f407b
Signed-off-by: Michael Lando <ml636r@att.com>

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));
+	}
+}