Catalog alignment
[sdc.git] / catalog-be / src / test / java / org / openecomp / sdc / be / components / impl / ServiceBussinessLogicBaseTestSetup.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * SDC
4  * ================================================================================
5  * Copyright (C) 2020 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  */
20
21 package org.openecomp.sdc.be.components.impl;
22
23 import fj.data.Either;
24 import org.junit.Before;
25 import org.mockito.Mockito;
26 import org.openecomp.sdc.ElementOperationMock;
27 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
28 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngine;
29 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
30 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
31 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
32 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
33 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
34 import org.openecomp.sdc.be.components.validation.UserValidations;
35 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
36 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
37 import org.openecomp.sdc.be.components.validation.component.ComponentFieldValidator;
38 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
39 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
40 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
41 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
42 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
43 import org.openecomp.sdc.be.components.validation.service.ServiceCategoryValidator;
44 import org.openecomp.sdc.be.components.validation.service.ServiceEnvironmentContextValidator;
45 import org.openecomp.sdc.be.components.validation.service.ServiceFieldValidator;
46 import org.openecomp.sdc.be.components.validation.service.ServiceFunctionValidator;
47 import org.openecomp.sdc.be.components.validation.service.ServiceInstantiationTypeValidator;
48 import org.openecomp.sdc.be.components.validation.service.ServiceNamingPolicyValidator;
49 import org.openecomp.sdc.be.components.validation.service.ServiceRoleValidator;
50 import org.openecomp.sdc.be.components.validation.service.ServiceTypeValidator;
51 import org.openecomp.sdc.be.components.validation.service.ServiceValidator;
52 import org.openecomp.sdc.be.config.ConfigurationManager;
53 import org.openecomp.sdc.be.dao.api.ActionStatus;
54 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
55 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
56 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
57 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
58 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
59 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
60 import org.openecomp.sdc.be.facade.operations.CatalogOperation;
61 import org.openecomp.sdc.be.impl.ComponentsUtils;
62 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
63 import org.openecomp.sdc.be.model.ArtifactDefinition;
64 import org.openecomp.sdc.be.model.Component;
65 import org.openecomp.sdc.be.model.Resource;
66 import org.openecomp.sdc.be.model.Service;
67 import org.openecomp.sdc.be.model.User;
68 import org.openecomp.sdc.be.model.category.CategoryDefinition;
69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
70 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
71 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
72 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
73 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
74 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
75 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
76 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
77 import org.openecomp.sdc.be.user.Role;
78 import org.openecomp.sdc.be.user.UserBusinessLogic;
79 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
80 import org.openecomp.sdc.common.api.ConfigurationSource;
81 import org.openecomp.sdc.common.api.Constants;
82 import org.openecomp.sdc.common.impl.ExternalConfiguration;
83 import org.openecomp.sdc.common.impl.FSConfigurationSource;
84 import org.openecomp.sdc.exception.ResponseFormat;
85 import org.springframework.web.context.WebApplicationContext;
86
87 import javax.servlet.ServletContext;
88 import java.util.ArrayList;
89 import java.util.Arrays;
90 import java.util.Collections;
91 import java.util.List;
92
93 import static org.junit.Assert.assertEquals;
94 import static org.mockito.ArgumentMatchers.anyString;
95 import static org.mockito.ArgumentMatchers.eq;
96 import static org.mockito.Mockito.when;
97
98 public class ServiceBussinessLogicBaseTestSetup extends BaseBusinessLogicMock{
99     ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
100     ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
101
102     protected ServiceBusinessLogic bl;
103     protected static final String SERVICE_CATEGORY = "Mobility";
104     protected static final String INSTANTIATION_TYPE = "A-la-carte";
105     protected final ServletContext servletContext = Mockito.mock(ServletContext.class);
106     protected UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
107     protected WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
108     protected WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
109     protected ResponseFormatManager responseManager = null;
110     protected ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
111     protected AuditCassandraDao auditingDao = Mockito.mock(AuditCassandraDao.class);
112     protected ArtifactsBusinessLogic artifactBl = Mockito.mock(ArtifactsBusinessLogic.class);
113     protected GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
114     protected JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
115     protected ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
116     protected GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
117     protected UserValidations userValidations = Mockito.mock(UserValidations.class);
118     protected ResourceAdminEvent auditArchive1 = Mockito.mock(ResourceAdminEvent.class);
119     protected CatalogOperation catalogOperation = Mockito.mock(CatalogOperation.class);
120     protected ResourceAdminEvent auditArchive2 = Mockito.mock(ResourceAdminEvent.class);
121     protected ResourceAdminEvent auditRestore = Mockito.mock(ResourceAdminEvent.class);
122     IElementOperation mockElementDao = new ElementOperationMock();
123     DistributionEngine distributionEngine =  Mockito.mock(DistributionEngine.class);
124     ServiceDistributionValidation serviceDistributionValidation = Mockito.mock(ServiceDistributionValidation.class);
125     ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
126     ForwardingPathValidator forwardingPathValidator = Mockito.mock(ForwardingPathValidator.class);
127     UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
128     protected final NodeFilterOperation serviceFilterOperation = Mockito.mock(NodeFilterOperation.class);
129     protected final NodeFilterValidator serviceFilterValidator = Mockito.mock(NodeFilterValidator.class);
130     protected ServiceTypeValidator serviceTypeValidator = new ServiceTypeValidator(componentsUtils);
131     protected ServiceCategoryValidator serviceCategoryValidator = new ServiceCategoryValidator(componentsUtils, mockElementDao);
132     protected ServiceRoleValidator serviceRoleValidator = new ServiceRoleValidator(componentsUtils);
133     protected ServiceFunctionValidator serviceFunctionValidator = new ServiceFunctionValidator(componentsUtils);
134     protected ServiceInstantiationTypeValidator serviceInstantiationTypeValidator = new ServiceInstantiationTypeValidator(componentsUtils);
135     protected ComponentDescriptionValidator componentDescriptionValidator =  new ComponentDescriptionValidator(componentsUtils);
136     protected ComponentProjectCodeValidator componentProjectCodeValidator =  new ComponentProjectCodeValidator(componentsUtils);
137     protected ComponentIconValidator componentIconValidator = new ComponentIconValidator(componentsUtils);
138     protected ComponentContactIdValidator componentContactIdValidator = new ComponentContactIdValidator(componentsUtils);
139     protected ComponentTagsValidator componentTagsValidator = new ComponentTagsValidator(componentsUtils);
140     protected ComponentNameValidator componentNameValidator = new ComponentNameValidator(componentsUtils, toscaOperationFacade);
141     protected final ComponentValidator componentValidator = Mockito.mock(ComponentValidator.class);
142     protected ServiceValidator serviceValidator = createServiceValidator();
143
144
145
146
147     protected User user = null;
148     protected Resource genericService = null;
149
150     protected static final String CERTIFIED_VERSION = "1.0";
151     protected static final String UNCERTIFIED_VERSION = "0.2";
152     protected static final String COMPONNET_ID = "myUniqueId";
153     protected static final String GENERIC_SERVICE_NAME = "org.openecomp.resource.abstract.nodes.service";
154
155     protected static final String SERVICE_ROLE = JsonPresentationFields.SERVICE_ROLE.getPresentation();
156     protected static final String SERVICE_TYPE = JsonPresentationFields.SERVICE_TYPE.getPresentation();
157     protected static final String SERVICE_FUNCTION = JsonPresentationFields.SERVICE_FUNCTION.getPresentation();
158
159     public ServiceBussinessLogicBaseTestSetup() {
160
161     }
162
163     protected ServiceValidator createServiceValidator() {
164         List<ComponentFieldValidator> componentFieldValidators = Arrays.asList(componentContactIdValidator,
165                 componentDescriptionValidator,
166                 componentIconValidator, componentNameValidator,
167                 new ComponentProjectCodeValidator(componentsUtils),
168                 componentTagsValidator);
169
170         List<ServiceFieldValidator> serviceFieldValidators = Arrays.asList(serviceCategoryValidator, new ServiceEnvironmentContextValidator(),
171                 serviceInstantiationTypeValidator, new ServiceNamingPolicyValidator(componentsUtils),
172                 serviceRoleValidator, serviceTypeValidator);
173         return new ServiceValidator(componentsUtils, componentFieldValidators, serviceFieldValidators);
174     }
175
176
177
178     @Before
179     public void setup() {
180
181         // Elements
182         IElementOperation mockElementDao = new ElementOperationMock();
183
184         // User data and management
185         user = new User();
186         user.setUserId("jh0003");
187         user.setFirstName("Jimmi");
188         user.setLastName("Hendrix");
189         user.setRole(Role.ADMIN.name());
190
191         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
192         when(userValidations.validateUserExists(eq("jh0003"))).thenReturn(user);
193         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
194 //        when(userValidations.validateUserRole(user))
195         // Servlet Context attributes
196         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
197 //        when(servletContext.getAttribute(Constants.SERVICE_OPERATION_MANAGER)).thenReturn(new ServiceOperation());
198         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
199         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
200         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
201         when(graphLockOperation.lockComponent(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
202         when(graphLockOperation.lockComponentByName(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Service))).thenReturn(StorageOperationStatus.OK);
203         when(catalogOperation.updateCatalog(Mockito.any(), Mockito.any())).thenReturn(ActionStatus.OK);
204         // artifact bussinesslogic
205         ArtifactDefinition artifactDef = new ArtifactDefinition();
206         when(artifactBl.createArtifactPlaceHolderInfo(Mockito.any(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(User.class), Mockito.any(ArtifactGroupTypeEnum.class))).thenReturn(artifactDef);
207
208         // createService
209         Service serviceResponse = createServiceObject(true);
210         Either<Component, StorageOperationStatus> eitherCreate = Either.left(serviceResponse);
211         when(toscaOperationFacade.createToscaComponent(Mockito.any(Component.class))).thenReturn(eitherCreate);
212         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
213         when(toscaOperationFacade.validateComponentNameExists("Service", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCount);
214         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
215         when(toscaOperationFacade.validateComponentNameExists("alreadyExist", null, ComponentTypeEnum.SERVICE)).thenReturn(eitherCountExist);
216         when(userValidations.validateUserExists(user)).thenReturn(user);
217
218         genericService = setupGenericServiceMock();
219         Either<Resource, StorageOperationStatus> findLatestGeneric = Either.left(genericService);
220         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_SERVICE_NAME)).thenReturn(findLatestGeneric);
221
222
223         bl = new ServiceBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
224                 groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
225                 artifactBl, distributionEngine, componentInstanceBusinessLogic,
226                 serviceDistributionValidation, forwardingPathValidator, uiComponentDataConverter,
227                 serviceFilterOperation, serviceFilterValidator, artifactToscaOperation, componentContactIdValidator,
228                 componentNameValidator, componentTagsValidator, componentValidator,
229                 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
230         bl.setComponentContactIdValidator(componentContactIdValidator);
231         bl.setComponentIconValidator(componentIconValidator);
232         bl.setComponentTagsValidator(componentTagsValidator);
233         bl.setComponentNameValidator(componentNameValidator);
234         bl.setComponentDescriptionValidator(componentDescriptionValidator);
235         bl.setComponentProjectCodeValidator(componentProjectCodeValidator);
236         bl.setServiceCategoryValidator(serviceCategoryValidator);
237         bl.setServiceTypeValidator(serviceTypeValidator);
238         bl.setServiceFunctionValidator(serviceFunctionValidator);
239         bl.setElementDao(mockElementDao);
240         bl.setUserAdmin(mockUserAdmin);
241         bl.setArtifactBl(artifactBl);
242         bl.setServiceValidator(createServiceValidator());
243         bl.setGraphLockOperation(graphLockOperation);
244         bl.setJanusGraphDao(mockJanusGraphDao);
245         bl.setToscaOperationFacade(toscaOperationFacade);
246         bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
247         bl.setComponentsUtils(componentsUtils);
248         bl.setCassandraAuditingDao(auditingDao);
249         bl.setUserValidations(userValidations);
250         bl.setCatalogOperations(catalogOperation);
251
252         mockAuditingDaoLogic();
253
254         responseManager = ResponseFormatManager.getInstance();
255
256
257     }
258
259     protected Resource setupGenericServiceMock(){
260         Resource genericService = new Resource();
261         genericService.setVersion("1.0");
262         genericService.setToscaResourceName(GENERIC_SERVICE_NAME);
263         return genericService;
264     }
265
266     protected Service createServiceObject(boolean afterCreate) {
267         Service service = new Service();
268         service.setUniqueId("sid");
269         service.setName("Service");
270         CategoryDefinition category = new CategoryDefinition();
271         category.setName(SERVICE_CATEGORY);
272         category.setIcons(Collections.singletonList("defaulticon"));
273         List<CategoryDefinition> categories = new ArrayList<>();
274         categories.add(category);
275         service.setCategories(categories);
276         service.setInstantiationType(INSTANTIATION_TYPE);
277
278         service.setDescription("description");
279         List<String> tgs = new ArrayList<>();
280         tgs.add(service.getName());
281         service.setTags(tgs);
282         // service.setVendorName("Motorola");
283         // service.setVendorRelease("1.0.0");
284         service.setIcon("defaulticon");
285         // service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
286         service.setContactId("aa1234");
287         service.setProjectCode("12345");
288         service.setEcompGeneratedNaming(true);
289
290         if (afterCreate) {
291             service.setVersion("0.1");
292             service.setUniqueId(service.getName() + ":" + service.getVersion());
293             service.setCreatorUserId(user.getUserId());
294             service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
295         }
296         return service;
297     }
298
299     private void mockAuditingDaoLogic() {
300         final ResourceAdminEvent createResourceAudit = new ResourceAdminEvent();
301         createResourceAudit.setModifier("Carlos Santana(cs0008)");
302         createResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
303         createResourceAudit.setCurrVersion("0.1");
304         createResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
305         createResourceAudit.setRequestId("3e65cea1-7403-4bc7-b461-e2544d83799f");
306         createResourceAudit.setDesc("OK");
307         createResourceAudit.setResourceType("Resource");
308         createResourceAudit.setStatus("201");
309         createResourceAudit.setPrevVersion("");
310         createResourceAudit.setAction("Create");
311         // fields.put("TIMESTAMP", "2015-11-22 09:19:12.977");
312         createResourceAudit.setPrevState("");
313         createResourceAudit.setResourceName("MyTestResource");
314         // createResourceAudit.setFields(fields);
315
316         final ResourceAdminEvent checkInResourceAudit = new ResourceAdminEvent();
317         checkInResourceAudit.setModifier("Carlos Santana(cs0008)");
318         checkInResourceAudit.setCurrState("NOT_CERTIFIED_CHECKIN");
319         checkInResourceAudit.setCurrVersion("0.1");
320         checkInResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
321         checkInResourceAudit.setRequestId("ffacbf5d-eeb1-43c6-a310-37fe7e1cc091");
322         checkInResourceAudit.setDesc("OK");
323         checkInResourceAudit.setComment("Stam");
324         checkInResourceAudit.setResourceType("Resource");
325         checkInResourceAudit.setStatus("200");
326         checkInResourceAudit.setPrevVersion("0.1");
327         checkInResourceAudit.setAction("Checkin");
328         // fields.put("TIMESTAMP", "2015-11-22 09:25:03.797");
329         checkInResourceAudit.setPrevState("NOT_CERTIFIED_CHECKOUT");
330         checkInResourceAudit.setResourceName("MyTestResource");
331
332         final ResourceAdminEvent checkOutResourceAudit = new ResourceAdminEvent();
333         checkOutResourceAudit.setModifier("Carlos Santana(cs0008)");
334         checkOutResourceAudit.setCurrState("NOT_CERTIFIED_CHECKOUT");
335         checkOutResourceAudit.setCurrVersion("0.2");
336         checkOutResourceAudit.setServiceInstanceId("82eddd99-0bd9-4742-ab0a-1bdb5e262a05");
337         checkOutResourceAudit.setRequestId("7add5078-4c16-4d74-9691-cc150e3c96b8");
338         checkOutResourceAudit.setDesc("OK");
339         checkOutResourceAudit.setComment("");
340         checkOutResourceAudit.setResourceType("Resource");
341         checkOutResourceAudit.setStatus("200");
342         checkOutResourceAudit.setPrevVersion("0.1");
343         checkOutResourceAudit.setAction("Checkout");
344         // fields.put("TIMESTAMP", "2015-11-22 09:39:41.024");
345         checkOutResourceAudit.setPrevState("NOT_CERTIFIED_CHECKIN");
346         checkOutResourceAudit.setResourceName("MyTestResource");
347         // checkOutResourceAudit.setFields(fields);
348
349         // Mockito.doAnswer(new Answer<Either<List<ESTimeBasedEvent>,
350         // ActionStatus> >() {
351         // public Either<List<ESTimeBasedEvent>, ActionStatus>
352         // answer(InvocationOnMock invocation) {
353         // final Either<List<ESTimeBasedEvent>, ActionStatus> either;
354         // final List<ESTimeBasedEvent> list;
355         // Object[] args = invocation.getArguments();
356         // Map<AuditingFieldsKey, Object> filterMap =
357         // (Map<AuditingFieldsKey, Object>) args[0];
358         // if( filterMap.equals(FILTER_MAP_CERTIFIED_VERSION) ){
359         // list = new
360         // ArrayList<ESTimeBasedEvent>(){{add(createResourceAudit);add(checkInResourceAudit);add(checkOutResourceAudit);}};
361         // either = Either.left(list);
362         //
363         // }
364         // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_PREV) ){
365         // list = new ArrayList<ESTimeBasedEvent>();
366         // either = Either.left(list);
367         // }
368         // else if( filterMap.equals(FILTER_MAP_UNCERTIFIED_VERSION_CURR) ){
369         // list = new
370         // ArrayList<ESTimeBasedEvent>(){{/*add(createResourceAudit);add(checkInResourceAudit);*/add(checkOutResourceAudit);}};
371         // either = Either.left(list);
372         // }
373         // else{
374         // either = null;
375         // }
376         // return either;
377         // }
378         // }).when(auditingDao).getFilteredResourceAdminAuditingEvents(Mockito.anyMap());
379         //
380         //
381         List<ResourceAdminEvent> list = new ArrayList<ResourceAdminEvent>() {
382             {
383                 add(createResourceAudit);
384                 add(checkInResourceAudit);
385                 add(checkOutResourceAudit);
386             }
387         };
388         Either<List<ResourceAdminEvent>, ActionStatus> result = Either.left(list);
389         Mockito.when(auditingDao.getByServiceInstanceId(Mockito.anyString())).thenReturn(result);
390
391         List<ResourceAdminEvent> listPrev = new ArrayList<>();
392         Either<List<ResourceAdminEvent>, ActionStatus> resultPrev = Either.left(listPrev);
393         Mockito.when(auditingDao.getAuditByServiceIdAndPrevVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultPrev);
394
395         List<ResourceAdminEvent> listCurr = new ArrayList<ResourceAdminEvent>() {
396             {
397                 add(checkOutResourceAudit);
398             }
399         };
400         Either<List<ResourceAdminEvent>, ActionStatus> resultCurr = Either.left(listCurr);
401         Mockito.when(auditingDao.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(resultCurr);
402
403         Either<List<ResourceAdminEvent>, ActionStatus> archiveAuditList = Either.left(Arrays.asList(auditArchive1, auditArchive2));
404         when(auditingDao.getArchiveAuditByServiceInstanceId(anyString())).thenReturn(archiveAuditList);
405
406         Either<List<ResourceAdminEvent>, ActionStatus> restoreAuditList = Either.left(Collections.singletonList(auditRestore));
407         when(auditingDao.getRestoreAuditByServiceInstanceId(anyString())).thenReturn(restoreAuditList);
408
409     }
410
411     protected void setupBeforeDeploy(String notifyAction, String requestAction, String did) {
412
413         DistributionNotificationEvent notifyEvent = new DistributionNotificationEvent();
414         notifyEvent.setAction(notifyAction);
415         notifyEvent.setDid(did);
416         notifyEvent.setStatus("200");
417
418         ResourceAdminEvent requestEvent = new ResourceAdminEvent();
419         requestEvent.setAction(requestAction);
420         requestEvent.setDid(did);
421         requestEvent.setStatus("200");
422
423         List<DistributionNotificationEvent> notifyResults = Collections.singletonList(notifyEvent);
424         Either<List<DistributionNotificationEvent>, ActionStatus> eitherNotify = Either.left(notifyResults);
425
426         Mockito.when(auditingDao.getDistributionNotify(Mockito.anyString(), Mockito.eq(notifyAction))).thenReturn(eitherNotify);
427
428         List<ResourceAdminEvent> requestResults = Collections.singletonList(requestEvent);
429         Either<List<ResourceAdminEvent>, ActionStatus> eitherRequest = Either.left(requestResults);
430         Mockito.when(auditingDao.getDistributionRequest(Mockito.anyString(), Mockito.eq(requestAction))).thenReturn(eitherRequest);
431
432         Either<Component, StorageOperationStatus> eitherService = Either.left(createServiceObject(true));
433         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.anyString())).thenReturn(eitherService);
434
435         Either<List<DistributionDeployEvent>, ActionStatus> emptyEventList = Either.left(Collections.emptyList());
436         Mockito.when(auditingDao.getDistributionDeployByStatus(Mockito.anyString(), Mockito.eq("DResult"), Mockito.anyString())).thenReturn(emptyEventList);
437     }
438
439     private void assertResponse(Either<Service, ResponseFormat> createResponse, ActionStatus expectedStatus, String... variables) {
440         assertResponse(createResponse.right().value(), expectedStatus, variables);
441     }
442
443     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
444         ResponseFormat actualResponse = e.getResponseFormat() != null ?
445                 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
446         assertResponse(actualResponse, expectedStatus, variables);
447     }
448
449     protected void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
450         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
451         assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
452         assertEquals("assert error description", expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
453     }
454
455 }