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

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