catalog-be/src/test/java/org/openecomp/sdc/be/components/BaseServiceBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.components;
  23
  24 import com.google.common.collect.Sets;
  25 import fj.data.Either;
  26 import org.junit.Before;
  27 import org.mockito.Mockito;
  28 import org.openecomp.sdc.ElementOperationMock;
  29 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  30 import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
  31 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  32 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  33 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  34 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  35 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogicTest;
  36 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  37 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
  38 import org.openecomp.sdc.be.components.utils.ComponentBusinessLogicMock;
  39 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  40 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
  41 import org.openecomp.sdc.be.dao.api.ActionStatus;
  42 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  43 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  44 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  45 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  48 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  49 import org.openecomp.sdc.be.impl.ComponentsUtils;
  50 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  51 import org.openecomp.sdc.be.model.ArtifactDefinition;
  52 import org.openecomp.sdc.be.model.Component;
  53 import org.openecomp.sdc.be.model.ComponentInstance;
  54 import org.openecomp.sdc.be.model.GroupInstance;
  55 import org.openecomp.sdc.be.model.Resource;
  56 import org.openecomp.sdc.be.model.Service;
  57 import org.openecomp.sdc.be.model.User;
  58 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  59 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
  60 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  61 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  62 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  63 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  64 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  65 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  66 import org.openecomp.sdc.be.user.Role;
  67 import org.openecomp.sdc.be.user.UserBusinessLogic;
  68 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  69 import org.openecomp.sdc.common.api.Constants;
  70 import org.openecomp.sdc.common.datastructure.AuditingFieldsKey;
  71 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74 import org.springframework.web.context.WebApplicationContext;
  75
  76 import javax.servlet.ServletContext;
  77 import java.util.ArrayList;
  78 import java.util.HashMap;
  79 import java.util.List;
  80 import java.util.Map;
  81
  82 import static org.mockito.ArgumentMatchers.any;
  83 import static org.mockito.Mockito.when;
  84
  85 public abstract class BaseServiceBusinessLogicTest extends ComponentBusinessLogicMock {
  86     private static final Logger log = LoggerFactory.getLogger(ServiceBusinessLogicTest.class);
  87     private static final String SERVICE_CATEGORY = "Mobility";
  88     private final ServletContext servletContext = Mockito.mock(ServletContext.class);
  89     private UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  90     private WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
  91     private WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
  92     protected final IDistributionEngine distributionEngine = Mockito.mock(IDistributionEngine.class);
  93     protected final ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
  94     protected final ServiceDistributionValidation serviceDistributionValidation = Mockito.mock(ServiceDistributionValidation.class);
  95     protected final ForwardingPathValidator forwardingPathValidator = Mockito.mock(ForwardingPathValidator.class);
  96     protected final UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
  97     protected final NodeFilterOperation serviceFilterOperation = Mockito.mock(NodeFilterOperation.class);
  98     protected final NodeFilterValidator serviceFilterValidator = Mockito.mock(NodeFilterValidator.class);
  99     private ServiceBusinessLogic bl;
 100     private ResponseFormatManager responseManager = null;
 101     private IElementOperation mockElementDao;
 102     private ComponentsUtils componentsUtils;
 103     private AuditCassandraDao auditingDao = Mockito.mock(AuditCassandraDao.class);
 104     private ArtifactsBusinessLogic artifactBl = Mockito.mock(ArtifactsBusinessLogic.class);
 105     private GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 106     private JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 107     private ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 108     private GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
 109     private ForwardingPathOperation forwardingPathOperation  = Mockito.mock(ForwardingPathOperation.class);
 110
 111     User user = null;
 112     Service serviceResponse = null;
 113     Resource genericService = null;
 114
 115     protected static final String CERTIFIED_VERSION = "1.0";
 116     protected static final String UNCERTIFIED_VERSION = "0.2";
 117     protected static final String COMPONNET_ID = "myUniqueId";
 118     protected static final String GENERIC_SERVICE_NAME = "org.openecomp.resource.abstract.nodes.service";
 119     protected static Map<AuditingFieldsKey, Object> FILTER_MAP_CERTIFIED_VERSION = new HashMap<>();
 120     protected static Map<AuditingFieldsKey, Object> FILTER_MAP_UNCERTIFIED_VERSION_CURR = new HashMap<>();
 121     protected static Map<AuditingFieldsKey, Object> FILTER_MAP_UNCERTIFIED_VERSION_PREV = new HashMap<>();
 122     @Before
 123     public void setup() {
 124
 125         ExternalConfiguration.setAppName("catalog-be");
 126         componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 127
 128         // Elements
 129         mockElementDao = new ElementOperationMock();
 130
 131         // User data and management
 132         user = new User();
 133         user.setUserId("jh0003");
 134         user.setFirstName("Jimmi");
 135         user.setLastName("Hendrix");
 136         user.setRole(Role.ADMIN.name());
 137
 138         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 139
 140         // Servlet Context attributes
 141         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 142 //        when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
 143         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 144         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 145         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 146         when(graphLockOperation.lockComponent(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 147         when(graphLockOperation.lockComponentByName(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
 148
 149         // artifact bussinesslogic
 150         ArtifactDefinition artifactDef = new ArtifactDefinition();
 151         when(artifactBl.createArtifactPlaceHolderInfo(Mockito.anyString(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(User.class), Mockito.any(ArtifactGroupTypeEnum.class))).thenReturn(artifactDef);
 152
 153         // createService
 154         serviceResponse = createServiceObject(true);
 155         Either<Component, StorageOperationStatus> eitherCreate = Either.left(serviceResponse);
 156         when(toscaOperationFacade.createToscaComponent(Mockito.any(Component.class))).thenReturn(eitherCreate);
 157         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 158         when(toscaOperationFacade.validateComponentNameExists("Service", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCount);
 159         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 160         when(toscaOperationFacade.validateComponentNameExists("alreadyExist", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCountExist);
 161
 162         genericService = setupGenericServiceMock();
 163         Either<Resource, StorageOperationStatus> findLatestGeneric = Either.left(genericService);
 164         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_SERVICE_NAME)).thenReturn(findLatestGeneric);
 165
 166         //forwardingPath
 167         when(forwardingPathOperation.addForwardingPath(any(),any())).thenReturn(Either.left(createMockPath()));
 168         when(forwardingPathOperation.updateForwardingPath(any(),any())).thenReturn(Either.left(createMockPath()));
 169         when(forwardingPathOperation.deleteForwardingPath(any(),any())).thenReturn(Either.left(Sets.newHashSet("Wow-It-Works")));
 170         when(toscaOperationFacade.getToscaElement("delete_forward_test")).thenReturn(Either.left(createServiceObject(true)));
 171
 172         bl = new ServiceBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 173             groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
 174             artifactsBusinessLogic, distributionEngine, componentInstanceBusinessLogic,
 175             serviceDistributionValidation, forwardingPathValidator, uiComponentDataConverter,
 176             serviceFilterOperation, serviceFilterValidator, artifactToscaOperation, componentContactIdValidator, componentNameValidator,
 177             componentTagsValidator, componentValidator, componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
 178         bl.setUserAdmin(mockUserAdmin);
 179         bl.setGraphLockOperation(graphLockOperation);
 180         bl.setJanusGraphDao(mockJanusGraphDao);
 181         bl.setToscaOperationFacade(toscaOperationFacade);
 182         bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
 183         bl.setComponentsUtils(componentsUtils);
 184         bl.setCassandraAuditingDao(auditingDao);
 185         bl.setForwardingPathOperation(forwardingPathOperation);
 186         bl.setToscaOperationFacade(toscaOperationFacade);
 187         mockAuditingDaoLogic();
 188
 189         responseManager = ResponseFormatManager.getInstance();
 190
 191     }
 192
 193     protected Component createNewService() {
 194
 195         Service service = new Service();
 196         int listSize = 3;
 197         service.setName("serviceName");
 198         service.setUniqueId("serviceUniqueId");
 199         List<ComponentInstance> componentInstances = new ArrayList<>();
 200         ComponentInstance ci;
 201         for(int i= 0; i<listSize; ++i){
 202             ci = new ComponentInstance();
 203             ci.setName("ciName" + i);
 204             ci.setUniqueId("ciId" + i);
 205             List<GroupInstance>  groupInstances= new ArrayList<>();
 206             GroupInstance gi;
 207             for(int j = 0; j<listSize; ++j){
 208                 gi = new GroupInstance();
 209                 gi.setName(ci.getName( )+ "giName" + j);
 210                 gi.setUniqueId(ci.getName() + "giId" + j);
 211                 groupInstances.add(gi);
 212             }
 213             ci.setGroupInstances(groupInstances);
 214             componentInstances.add(ci);
 215         }
 216         service.setComponentInstances(componentInstances);
 217         return service;
 218     }
 219
 220     private void mockAuditingDaoLogic() {
 221         FILTER_MAP_CERTIFIED_VERSION.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, COMPONNET_ID);
 222         FILTER_MAP_UNCERTIFIED_VERSION_CURR.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, COMPONNET_ID);
 223         FILTER_MAP_UNCERTIFIED_VERSION_PREV.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, COMPONNET_ID);
 224
 225         FILTER_MAP_UNCERTIFIED_VERSION_CURR.put(AuditingFieldsKey.AUDIT_RESOURCE_CURR_VERSION, UNCERTIFIED_VERSION);
 226         FILTER_MAP_UNCERTIFIED_VERSION_PREV.put(AuditingFieldsKey.AUDIT_RESOURCE_PREV_VERSION, UNCERTIFIED_VERSION);
 227
 228         final ResourceAdminEvent createResourceAudit = new ResourceAdminEvent();
 229         createResourceAudit.setModifier("Carlos Santana(cs0008)");
 230         createResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
 231         createResourceAudit.setCurrVersion("0.1");
 232         createResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 233         createResourceAudit.setRequestId("3e65cea1-7403-4bc7-b461-e2544d83799f");
 234         createResourceAudit.setDesc("OK");
 235         createResourceAudit.setResourceType("Resource");
 236         createResourceAudit.setStatus("201");
 237         createResourceAudit.setPrevVersion("");
 238         createResourceAudit.setAction("Create");
 239         // fields.put("TIMESTAMP", "2015-11-22 09:19:12.977");
 240         createResourceAudit.setPrevState("");
 241         createResourceAudit.setResourceName("MyTestResource");
 242         // createResourceAudit.setFields(fields);
 243
 244         final ResourceAdminEvent checkInResourceAudit = new ResourceAdminEvent();
 245         checkInResourceAudit.setModifier("Carlos Santana(cs0008)");
 246         checkInResourceAudit.setCurrState("NOT_CERTIFIED_CHECKIN");
 247         checkInResourceAudit.setCurrVersion("0.1");
 248         checkInResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 249         checkInResourceAudit.setRequestId("ffacbf5d-eeb1-43c6-a310-37fe7e1cc091");
 250         checkInResourceAudit.setDesc("OK");
 251         checkInResourceAudit.setComment("Stam");
 252         checkInResourceAudit.setResourceType("Resource");
 253         checkInResourceAudit.setStatus("200");
 254         checkInResourceAudit.setPrevVersion("0.1");
 255         checkInResourceAudit.setAction("Checkin");
 256         // fields.put("TIMESTAMP", "2015-11-22 09:25:03.797");
 257         checkInResourceAudit.setPrevState("NOT_CERTIFIED_CHECKOUT");
 258         checkInResourceAudit.setResourceName("MyTestResource");
 259
 260         final ResourceAdminEvent checkOutResourceAudit = new ResourceAdminEvent();
 261         checkOutResourceAudit.setModifier("Carlos Santana(cs0008)");
 262         checkOutResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
 263         checkOutResourceAudit.setCurrVersion("0.2");
 264         checkOutResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
 265         checkOutResourceAudit.setRequestId("7add5078-4c16-4d74-9691-cc150e3c96b8");
 266         checkOutResourceAudit.setDesc("OK");
 267         checkOutResourceAudit.setComment("");
 268         checkOutResourceAudit.setResourceType("Resource");
 269         checkOutResourceAudit.setStatus("200");
 270         checkOutResourceAudit.setPrevVersion("0.1");
 271         checkOutResourceAudit.setAction("Checkout");
 272         // fields.put("TIMESTAMP", "2015-11-22 09:39:41.024");
 273         checkOutResourceAudit.setPrevState("NOT_CERTIFIED_CHECKIN");
 274         checkOutResourceAudit.setResourceName("MyTestResource");
 275         // checkOutResourceAudit.setFields(fields);
 276
 277         List<ResourceAdminEvent> list = new ArrayList<ResourceAdminEvent>() {
 278             {
 279                 add(createResourceAudit);
 280                 add(checkInResourceAudit);
 281                 add(checkOutResourceAudit);
 282             }
 283         };
 284         Either<List<ResourceAdminEvent>, ActionStatus> result = Either.left(list);
 285         Mockito.when(auditingDao.getByServiceInstanceId(Mockito.anyString())).thenReturn(result);
 286
 287         List<ResourceAdminEvent> listPrev = new ArrayList<>();
 288         Either<List<ResourceAdminEvent>, ActionStatus> resultPrev = Either.left(listPrev);
 289         Mockito.when(auditingDao.getAuditByServiceIdAndPrevVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultPrev);
 290
 291         List<ResourceAdminEvent> listCurr = new ArrayList<ResourceAdminEvent>() {
 292             {
 293                 add(checkOutResourceAudit);
 294             }
 295         };
 296         Either<List<ResourceAdminEvent>, ActionStatus> resultCurr = Either.left(listCurr);
 297         Mockito.when(auditingDao.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultCurr);
 298
 299     }
 300
 301     protected Service createServiceObject(boolean afterCreate) {
 302         Service service = new Service();
 303         service.setName("Service");
 304         CategoryDefinition category = new CategoryDefinition();
 305         category.setName(SERVICE_CATEGORY);
 306         List<CategoryDefinition> categories = new ArrayList<>();
 307         categories.add(category);
 308         service.setCategories(categories);
 309
 310         service.setDescription("description");
 311         List<String> tgs = new ArrayList<>();
 312         tgs.add(service.getName());
 313         service.setTags(tgs);
 314         // service.setVendorName("Motorola");
 315         // service.setVendorRelease("1.0.0");
 316         service.setIcon("MyIcon");
 317         // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 318         service.setContactId("aa1234");
 319         service.setProjectCode("12345");
 320
 321         if (afterCreate) {
 322             service.setVersion("0.1");
 323             service.setUniqueId(service.getName() + ":" + service.getVersion());
 324             service.setCreatorUserId(user.getUserId());
 325             service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 326         }
 327         return service;
 328     }
 329
 330     protected Resource setupGenericServiceMock(){
 331         Resource genericService = new Resource();
 332         genericService.setVersion("1.0");
 333         genericService.setToscaResourceName(GENERIC_SERVICE_NAME);
 334         return genericService;
 335     }
 336
 337     protected static ForwardingPathDataDefinition forwardingPathDataDefinition;
 338
 339     protected static ForwardingPathDataDefinition createMockPath() {
 340         if (forwardingPathDataDefinition != null){
 341             return forwardingPathDataDefinition ;
 342         }
 343         forwardingPathDataDefinition = new ForwardingPathDataDefinition("Yoyo");
 344         forwardingPathDataDefinition.setUniqueId(java.util.UUID.randomUUID().toString());
 345         forwardingPathDataDefinition.setDestinationPortNumber("414155");
 346         forwardingPathDataDefinition.setProtocol("http");
 347         org.openecomp.sdc.be.datatypes.elements.ListDataDefinition<org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition> forwardingPathElementDataDefinitionListDataDefinition = new org.openecomp.sdc.be.datatypes.elements.ListDataDefinition<>();
 348         forwardingPathElementDataDefinitionListDataDefinition.add(new ForwardingPathElementDataDefinition("fromNode","toNode", "333","444","2222","5555"));
 349         forwardingPathElementDataDefinitionListDataDefinition.add(new ForwardingPathElementDataDefinition("toNode","toNode2", "4444","44444","4","44"));
 350         forwardingPathDataDefinition.setPathElements(forwardingPathElementDataDefinitionListDataDefinition);
 351         return forwardingPathDataDefinition;
 352     }
 353 }