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

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