/*- * ============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.Ignore; 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 = "muUserId"; @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 getAndWatchConfiguration(Class className, // ConfigurationListener configurationListener) { // // TODO Auto-generated method stub // return null; // } // // @Override // public void addWatchConfiguration(Class 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 graphResult = titanGenericDao.getGraph(); TitanGraph graph = graphResult.left().value(); Iterable vertices = graph.query().vertices(); if (vertices != null) { Iterator iterator = vertices.iterator(); while (iterator.hasNext()) { TitanVertex vertex = iterator.next(); // graph.removeVertex(vertex); vertex.remove(); } } titanGenericDao.commit(); } @Test @Ignore public void getOwnerTest() { Resource resultResource = createTestResource(checkoutUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); Either 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 @Ignore public void checkoutCertifiedTest() { Resource resultResource = createTestResource(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null); String origUniqueId = resultResource.getUniqueId(); Either origResourceResult = resourceOperation.getResource(origUniqueId); Resource origResource = origResourceResult.left().value(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkout Either checkoutResponse = (Either) 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 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 getOrigResource = resourceOperation.getResource(origUniqueId); assertEquals("check resource created", true, getOrigResource.isLeft()); // assertEquals("assert original resource not changed", origResource, // getOrigResource.left().value()); } @Test @Ignore public void checkoutDefaultTest() { Resource resultResource = createTestResource(checkinUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkout Either checkoutResponse = (Either) 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 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 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 @Ignore public void checkoutFullResourceTest() { Resource origResource = createFullTestResource(checkinUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); String origUniqueId = origResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkout Either checkoutResponse = (Either) 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 interfaces = checkoutResource.getInterfaces(); assertTrue(interfaces.containsKey(INTERFACE_NAME)); InterfaceDefinition interfaceDef = interfaces.get(INTERFACE_NAME); Map operations = interfaceDef.getOperationsMap(); 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 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 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 @Ignore public void getResourceOwnerResourceNotExistTest() { // create resource metadata Resource resource = buildResourceMetadata(adminUser.getUserId(), CATEGORY_NAME); resource.setLifecycleState(LifecycleStateEnum.CERTIFIED); resource.setUniqueId("my-resource.0.1"); Either origResourceResult = resourceOperation.getResource("my-resource.0.1"); assertEquals("assert resource not exist", true, origResourceResult.isRight()); // get resource owner Either 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 @Ignore public void checkoutResourceTwice() { Resource resultResource = createTestResource(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null); String origUniqueId = resultResource.getUniqueId(); Either origResourceResult = resourceOperation.getResource(origUniqueId); Resource origResource = origResourceResult.left().value(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // first checkout Either checkoutResponse1 = (Either) lifecycleOperation.checkoutComponent(NodeTypeEnum.Resource, resultResource, checkoutUser, resourceOwner, false); assertEquals("check resource object is returned", true, checkoutResponse1.isLeft()); // second checkout Either checkoutResponse2 = (Either) 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 getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkout Either 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 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 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 @Ignore 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 getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); Either serviceBeforeCheckout = serviceOperation.getService(origUniqueId, true); assertTrue(serviceBeforeCheckout.isLeft()); origService = serviceBeforeCheckout.left().value(); // checkout Either 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 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 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 @Ignore public void checkoutServiceTwice() { Service resultResource = createTestService(adminUser.getUserId(), "1.0", LifecycleStateEnum.CERTIFIED, null); String origUniqueId = resultResource.getUniqueId(); Either origResourceResult = serviceOperation.getService(origUniqueId); Service origResource = origResourceResult.left().value(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // first checkout Either checkoutResponse1 = lifecycleOperation.checkoutComponent(NodeTypeEnum.Service, resultResource, checkoutUser, resourceOwner, false); assertEquals("check resource object is returned", true, checkoutResponse1.isLeft()); // second checkout Either 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 @Ignore public void checkinDefaultTest() { Resource resultResource = createTestResource(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either checkinResponse = (Either) 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 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 @Ignore public void checkinFromRfcTest() { Resource resultResource = createTestResource(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either checkinResponse = (Either) lifecycleOperation.checkinComponent(NodeTypeEnum.Resource, resultResource, checkinUser, resourceOwner, false); assertEquals("check resource object is returned", true, checkinResponse.isLeft()); // rfc Either rfcResponse = (Either) lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Resource, checkinResponse.left().value(), rfcUser, checkinUser, false); assertEquals("check resource object is returned", true, checkinResponse.isLeft()); // checkin (cancel rfc) checkinResponse = (Either) 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 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 @Ignore public void checkinServiceDefaultTest() { Service resultService = createTestService(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultService.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either 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 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 @Ignore public void checkinServiceFromRfcTest() { Service resultResource = createTestService(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either checkinResponse = lifecycleOperation.checkinComponent(NodeTypeEnum.Service, resultResource, checkinUser, resourceOwner, false); assertEquals("check service object is returned", true, checkinResponse.isLeft()); // rfc Either 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 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 @Ignore public void undoCheckoutNewResourceTest() { Resource resultResource = createTestResource(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // // undo checkout Either undoCheckoutResponse = (Either) lifecycleOperation.undoCheckout(NodeTypeEnum.Resource, resultResource, adminUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); Either origResourceResult = resourceOperation.getResource(origUniqueId); assertTrue(origResourceResult.isRight()); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ } @Test @Ignore public void undoCheckoutNewFullResourceTest() { Resource resultResource = createFullTestResource(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // undo checkout Either undoCheckoutResponse = (Either) lifecycleOperation.undoCheckout(NodeTypeEnum.Resource, resultResource, adminUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); Either origResourceResult = resourceOperation.getResource(origUniqueId); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ assertTrue(origResourceResult.isRight()); String interfaceId = origUniqueId + "." + INTERFACE_NAME; Either node = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class); assertTrue(node.isRight()); String operationId = interfaceId + "." + INTERFACE_OPERATION_CREATE; Either op = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), operationId, OperationData.class); assertTrue(op.isRight()); String capabilityId = "capability." + origUniqueId + "." + CAPABILITY_NAME; Either capability = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Capability), capabilityId, CapabilityData.class); assertTrue(capability.isRight()); String requirementId = origUniqueId + "." + REQUIREMENT_NAME; Either req = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Requirement), requirementId, RequirementData.class); assertTrue(req.isRight()); } @Test @Ignore public void undoCheckoutExistingResourceTest() { Resource resultResource = createTestResource(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // get resource owner Either 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 result2 = (Either) 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 undoCheckoutResponse = (Either) lifecycleOperation.undoCheckout(NodeTypeEnum.Resource, resultResource2, checkoutUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); // get previous resource Either 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 origResourceResult = resourceOperation.getResource(resultResource2.getUniqueId()); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ assertTrue(origResourceResult.isRight()); } /**** SERVICE ***/ @Test @Ignore public void undoCheckoutNewServiceTest() { Service resultResource = createTestService(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, null); String origUniqueId = resultResource.getUniqueId(); Either getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // // undo checkout Either undoCheckoutResponse = lifecycleOperation.undoCheckout(NodeTypeEnum.Service, resultResource, adminUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); Either origResourceResult = serviceOperation.getService(origUniqueId); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ assertTrue(origResourceResult.isRight()); } @Test @Ignore 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 getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); Either service = serviceOperation.getService(origUniqueId); assertTrue(service.isLeft()); Service resultResource = service.left().value(); List resourceInstances = resultResource.getComponentInstances(); // undo checkout Either undoCheckoutResponse = lifecycleOperation.undoCheckout(NodeTypeEnum.Service, resultResource, adminUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); Either origResourceResult = serviceOperation.getService(origUniqueId); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ assertTrue(origResourceResult.isRight()); for (ComponentInstance ri : resourceInstances) { Either node = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), ri.getUniqueId(), ComponentInstanceData.class); assertTrue(node.isRight()); } } @Test @Ignore public void undoCheckoutExistingServiceTest() { Service resultResource = createTestService(adminUser.getUserId(), "0.1", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // get resource owner Either 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 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 undoCheckoutResponse = lifecycleOperation.undoCheckout(NodeTypeEnum.Service, resultResource2, checkoutUser, resourceOwner, false); assertEquals("check resource object is returned", true, undoCheckoutResponse.isLeft()); // get previous resource Either 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 origResourceResult = serviceOperation.getService(result2Uid); /* * assertTrue(origResourceResult.isLeft()); assertTrue(origResourceResult.left().value().getIsDeleted() == true); */ assertTrue(origResourceResult.isRight()); } /**************************** * CERTIFICATION REQUEST ********************************************************************/ @Test @Ignore public void certReqDefaultTest() { Resource actualResource = testCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); // assert relations ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId()); Map props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 @Ignore public void atomicCheckinCertReqTest() { Resource actualResource = testCertificationRequest(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); // assert relations ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId()); Map props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Resource, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either certReqResponse = (Either) 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 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 @Ignore 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 @Ignore 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.READY_FOR_CERTIFICATION); Either 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 getOwnerResponse = lifecycleOperation.getComponentOwner(origUniqueId, NodeTypeEnum.Service, false); assertEquals("check user object is returned", true, getOwnerResponse.isLeft()); User resourceOwner = getOwnerResponse.left().value(); // checkin Either 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 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 @Ignore public void startCertificationTest() { Resource resultResource = createTestResource(checkinUser.getUserId(), "0.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // certification request Either requestCertificationResult = (Either) lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = (Either) lifecycleOperation.startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Resource actualResource = startCertificationResult.left().value(); // get resource owner Either 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void startServiceCertificationTest() { Service resultResource = createTestService(checkinUser.getUserId(), "0.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // certification request Either requestCertificationResult = lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Service, resultResource, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = lifecycleOperation.startComponentCertification(NodeTypeEnum.Service, resultResource, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Service actualResource = (Service) startCertificationResult.left().value(); // get resource owner Either 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 props = new HashMap(); props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void failCertificationTest() { Resource actualResource = certificationStatusChange(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, checkinUser); // assert relations ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId()); Map props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void failCertificationServiceTest() { Service actualService = certificationStatusChangeService(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, checkinUser); // assert relations ServiceMetadataData resourceData = new ServiceMetadataData((ServiceMetadataDataDefinition) actualService.getComponentMetadataDefinition().getMetadataDataDefinition()); Map props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void cancelCertificationTest() { Resource actualResource = certificationStatusChange(LifecycleStateEnum.READY_FOR_CERTIFICATION, rfcUser); // assert relations ResourceMetadataData resourceData = new ResourceMetadataData(); resourceData.getMetadataDataDefinition().setUniqueId(actualResource.getUniqueId()); Map props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void cancelCertificationServiceTest() { Service actualService = certificationStatusChangeService(LifecycleStateEnum.READY_FOR_CERTIFICATION, rfcUser); // assert relations ServiceMetadataData ServiceNode = new ServiceMetadataData(); ServiceNode.getMetadataDataDefinition().setUniqueId(actualService.getUniqueId()); Map props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void certifyTest() { Resource resultResource = createTestResource(checkinUser.getUserId(), "0.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // certification request Either requestCertificationResult = (Either) lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = (Either) lifecycleOperation.startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Resource actualResource = startCertificationResult.left().value(); // cancel certification Either CertificationResult = lifecycleOperation.certifyComponent(NodeTypeEnum.Resource, actualResource, testerUser, testerUser, false); assertEquals(true, CertificationResult.isLeft()); actualResource = (Resource) CertificationResult.left().value(); // get resource owner Either 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 props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore public void certifyServiceTest() { Service resultService = createTestService(checkinUser.getUserId(), "0.2", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN, null); // certification request Either requestCertificationResult = lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Service, resultService, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = lifecycleOperation.startComponentCertification(NodeTypeEnum.Service, resultService, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Service actualService = (Service) startCertificationResult.left().value(); // cancel certification Either CertificationResult = lifecycleOperation.certifyComponent(NodeTypeEnum.Service, actualService, testerUser, testerUser, false); assertEquals(true, CertificationResult.isLeft()); actualService = (Service) CertificationResult.left().value(); // get resource owner Either 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 props = new HashMap(); // old edges removed props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS); Either 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 @Ignore 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 deleteOldComponentVersions = lifecycleOperation.deleteOldComponentVersions(NodeTypeEnum.Resource, certifiedResource.getName(), certifiedResource.getUUID(), false); assertTrue(deleteOldComponentVersions.isLeft()); String resourceName = certifiedResource.getName(); Either, 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 testDeleteOldVersionsResourceWithArtifacts(){ // // simulate // Resource resource = createFullTestResource(checkinUser.getUserId(), // "1.0", LifecycleStateEnum.CERTIFIED); // // // checkout // Either checkoutResource = // lifecycleOperation.checkoutResource(resource, checkinUser, checkinUser, // false); // assertTrue(checkoutResource.isLeft()); // Either getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "1.1", false); // assertTrue(getResource.isLeft()); // // // rfc // resource = getResource.left().value(); // Either requestCertification = // lifecycleOperation.requestCertification(resource, rfcUser, checkinUser, // false); // assertTrue(requestCertification.isLeft()); // getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "1.1", false); // assertTrue(getResource.isLeft()); // // // start cert // resource = getResource.left().value(); // Either startCertification = // lifecycleOperation.startCertificationResource(resource, testerUser, // rfcUser, false); // assertTrue(startCertification.isLeft()); // getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "1.1", false); // assertTrue(getResource.isLeft()); // // // certify // resource = getResource.left().value(); // Either certify = // lifecycleOperation.certifyResource(resource, testerUser, testerUser, // false); // assertTrue(certify.isLeft()); // getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "1.1", false); // assertTrue(getResource.isLeft()); // resource = getResource.left().value(); // // // Either, StorageOperationStatus> // deleteOldComponentVersions = lifecycleOperation // .deleteOldComponentVersions(NodeTypeEnum.Resource, // resource.getResourceName(), resource.getUUID(), false); // // assertTrue(deleteOldComponentVersions.isLeft()); // assertEquals(2, deleteOldComponentVersions.left().value().size()); // // String resourceName = resource.getResourceName(); // getResource = resourceOperation.getResourceByNameAndVersion(resourceName, // "1.0", false); // assertTrue(getResource.isLeft()); // // getResource = resourceOperation.getResourceByNameAndVersion(resourceName, // "2.0", false); // assertTrue(getResource.isLeft()); // // getResource = resourceOperation.getResourceByNameAndVersion(resourceName, // "1.1", false); // assertTrue(getResource.isRight()); // assertEquals(StorageOperationStatus.NOT_FOUND, // getResource.right().value()); // // } // @Test // public void testDeleteOldVersionsResourceWithArtifactsDerived(){ // // simulate // Resource resourceRoot = createFullTestResource(checkinUser.getUserId(), // "1.0", LifecycleStateEnum.CERTIFIED); // Resource resource = buildResourceMetadata(checkinUser.getUserId(), // CATEGORY_NAME); // resource.setResourceName("myDerivedResource"); // resource.setResourceVersion("0.1"); // resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); // List derived = new ArrayList<>(); // derived.add(resourceRoot.getResourceName()); // resource.setDerivedFrom(derived); // // Either result = // resourceOperation.createResource(resource); // assertEquals("check resource created", true, result.isLeft()); // resource = result.left().value(); // // // resource inherits the artifacts from parent // assertNotNull(resource.getInterfaces().get(INTERFACE_NAME).getOperations().get(INTERFACE_OPERATION_CREATE).getImplementation()); // // // rfc // Either requestCertification = // lifecycleOperation.requestCertification(resource, rfcUser, checkinUser, // false); // assertTrue(requestCertification.isLeft()); // Either getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "0.1", false); // assertTrue(getResource.isLeft()); // // // start cert // resource = getResource.left().value(); // Either startCertification = // lifecycleOperation.startCertificationResource(resource, testerUser, // rfcUser, false); // assertTrue(startCertification.isLeft()); // getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "0.1", false); // assertTrue(getResource.isLeft()); // // // certify // resource = getResource.left().value(); // Either certify = // lifecycleOperation.certifyResource(resource, testerUser, testerUser, // false); // assertTrue(certify.isLeft()); // getResource = // resourceOperation.getResourceByNameAndVersion(resource.getResourceName(), // "0.1", false); // assertTrue(getResource.isLeft()); // resource = getResource.left().value(); // // // Either, StorageOperationStatus> // deleteOldComponentVersions = lifecycleOperation // .deleteOldComponentVersions(NodeTypeEnum.Resource, // resource.getResourceName(), resource.getUUID(), false); // // assertTrue(deleteOldComponentVersions.isLeft()); // // // resource artifacts are not really the resource's, they are the // parent's artifacts // assertTrue(deleteOldComponentVersions.left().value().isEmpty()); // // String resourceName = resource.getResourceName(); // getResource = resourceOperation.getResourceByNameAndVersion(resourceName, // "1.0", false); // assertTrue(getResource.isLeft()); // // getResource = resourceOperation.getResourceByNameAndVersion(resourceName, // "0.1", false); // assertTrue(getResource.isRight()); // assertEquals(StorageOperationStatus.NOT_FOUND, // getResource.right().value()); // // } @Test @Ignore 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 deleteOldComponentVersions = lifecycleOperation.deleteOldComponentVersions(NodeTypeEnum.Service, certifiedService.getName(), certifiedService.getUUID(), false); assertTrue(deleteOldComponentVersions.isLeft()); String resourceName = certifiedService.getName(); Either 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 requestCertificationResult = (Either) lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Resource, resultResource, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = (Either) lifecycleOperation.startComponentCertification(NodeTypeEnum.Resource, resultResource, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Resource actualResource = startCertificationResult.left().value(); // cancel certification Either failCertificationResult = (Either) lifecycleOperation.cancelOrFailCertification(NodeTypeEnum.Resource, actualResource, testerUser, testerUser, nextState, false); assertEquals(true, failCertificationResult.isLeft()); actualResource = failCertificationResult.left().value(); // get resource owner Either 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 requestCertificationResult = lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Service, resultService, rfcUser, checkinUser, false); assertTrue(requestCertificationResult.isLeft()); // start certification Either startCertificationResult = lifecycleOperation.startComponentCertification(NodeTypeEnum.Service, resultService, testerUser, rfcUser, false); assertEquals(true, startCertificationResult.isLeft()); Service actualService = (Service) startCertificationResult.left().value(); // cancel certification Either failCertificationResult = lifecycleOperation.cancelOrFailCertification(NodeTypeEnum.Service, actualService, testerUser, testerUser, nextState, false); assertEquals(true, failCertificationResult.isLeft()); actualService = (Service) failCertificationResult.left().value(); // get resource owner Either 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 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 categories = new ArrayList<>(); categories.add(category); service.setCategories(categories); service.setIcon("images/my.png"); List tags = new ArrayList(); tags.add("TAG1"); tags.add("TAG2"); service.setTags(tags); service.setUUID(uuid); service.setLifecycleState(state); Either 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); // inter.setUniqueId(UniqueIdBuilder.buildResourceUniqueId(resource2.getResourceName(), // resource2.getResourceVersion())+"."+INTERFACE_NAME); 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 ops = new HashMap<>(); ops.put(INTERFACE_OPERATION_CREATE, operation); inter.setOperationsMap(ops); Map 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> capabilities = new HashMap<>(); List validSourceTypes = new ArrayList(); validSourceTypes.add("tosca.nodes.SC"); capabilityDefinition.setValidSourceTypes(validSourceTypes); List caplist = new ArrayList(); 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> requirements = new HashMap<>(); List reqlist = new ArrayList(); reqlist.add(reqDefinition); requirements.put(capabilityTypeName, reqlist); resource2.setRequirements(requirements); Either 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 addArifactToResource = artifactOperation.addArifactToComponent(artifactDef, resultResource.getUniqueId(), NodeTypeEnum.Resource, false, true); assertTrue(addArifactToResource.isLeft()); Either 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 properties = new HashMap(); String propName1 = "disk_size"; PropertyDefinition property1 = buildProperty1(); properties.put(propName1, property1); capabilityTypeDefinition.setProperties(properties); Either 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 tags = new ArrayList(); 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; } /* * public void deleteAndCreateCategory(String category) { CategoryData categoryData = new CategoryData(); categoryData.setName(category); * * Either node = titanGenericDao.getNode(categoryData.getUniqueIdKey(), categoryData, CategoryData.class); if (node.isRight()){ //titanGenericDao.deleteNode(categoryData, CategoryData.class); * Either createNode = titanGenericDao .createNode(categoryData, CategoryData.class); System.out.println("after creating caetgory " + createNode); } */ 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 constraints = new ArrayList(); 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 artifact = artifactOperation.addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true); assertTrue(artifact.isLeft()); return artifactInfo; } }