2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.externalApis;
23 import org.junit.Rule;
24 import org.junit.rules.TestName;
25 import org.openecomp.sdc.be.dao.api.ActionStatus;
26 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
27 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
28 import org.openecomp.sdc.be.model.DistributionStatusEnum;
29 import org.openecomp.sdc.be.model.Resource;
30 import org.openecomp.sdc.be.model.Service;
31 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
32 import org.openecomp.sdc.ci.tests.datatypes.*;
33 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
34 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
35 import org.openecomp.sdc.ci.tests.utils.Utils;
36 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
37 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
38 import org.openecomp.sdc.ci.tests.utils.rest.*;
39 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
40 import org.slf4j.Logger;
41 import org.slf4j.LoggerFactory;
42 import org.testng.annotations.Test;
44 import java.util.ArrayList;
45 import java.util.Arrays;
46 import java.util.List;
48 import static org.testng.AssertJUnit.assertEquals;
49 import static org.testng.AssertJUnit.assertNotNull;
51 public class GetFilteredAssetServlet extends ComponentBaseTest {
53 private static Logger log = LoggerFactory.getLogger(GetAssetServlet.class.getName());
54 protected final static String categoryFilterKey = "category";
55 protected final static String subCategoryFilterKey = "subCategory";
56 protected final static String distributionStatusFilterKey = "distributionStatus";
57 protected final static String serviceKey = "service";
58 protected final static String resourceKey = "resource";
59 protected final static String resourceType = "resourceType";
60 protected final static String validFilterParameters = "[" + resourceType + ", "+ subCategoryFilterKey + ", " + categoryFilterKey + "]";
63 public static TestName name = new TestName();
65 public GetFilteredAssetServlet() {
66 super(name, GetFilteredAssetServlet.class.getName());
70 // public void setup() throws Exception {
71 // AtomicOperationUtils.createDefaultConsumer(true);
77 @Test // (enabled = false)
78 public void getResourceAssetBySpecifiedCategory() throws Exception {
79 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory() };
80 List<String> expectedAssetNamesList = new ArrayList<>();
82 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
83 expectedAssetNamesList.add(resource1.getName());
84 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, UserRoleEnum.DESIGNER, true).left().value();
85 expectedAssetNamesList.add(resource2.getName());
86 Resource resource3 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.NETWORK_CONNECTIVITY_CON_POINT, UserRoleEnum.DESIGNER, true).left().value();
88 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
89 BaseRestUtils.checkSuccess(assetResponse);
91 List<ResourceAssetStructure> resourceAssetList = AssetRestUtils.getResourceAssetList(assetResponse);
92 List<String> getActualAssetNamesList = AssetRestUtils.getResourceNamesList(resourceAssetList);
93 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
95 /*// Validate audit message
96 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
100 // 2 resources has the same category and different subcategory
101 @Test // (enabled = false)
102 public void getResourceAssetBySpecifiedCategoryAndSubCategory() throws Exception {
103 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory(), subCategoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getSubCategory() };
104 // String[] filter2 = {categoryFilterKey + "=" +
105 // ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getCategory(),
106 // subCategoryFilterKey + "=" +
107 // ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getSubCategory()};
108 List<String> expectedAssetNamesList = new ArrayList<>();
110 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
111 expectedAssetNamesList.add(resource1.getName());
112 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, UserRoleEnum.DESIGNER, true).left().value();
114 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
115 BaseRestUtils.checkSuccess(assetResponse);
117 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
118 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
119 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
121 /*// Validate audit message
122 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
125 @Test // (enabled = false)
126 public void getResourceAssetBySpecifiedSubCategoryAndCategory() throws Exception {
127 String[] filter = { subCategoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_DATABASE.getSubCategory(), categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_DATABASE.getCategory(), };
128 List<String> expectedAssetNamesList = new ArrayList<>();
130 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
131 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
132 expectedAssetNamesList.add(resource2.getName());
134 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
135 BaseRestUtils.checkSuccess(assetResponse);
137 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
138 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
139 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
141 /*// Validate audit message
142 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
146 @Test // (enabled = false)
147 public void getResourceAssetCategoryNotExists() throws Exception {
148 String[] filter = { categoryFilterKey + "=" + "NotExistingCategory" };
150 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
151 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
153 assertNotNull("check response object is not null after create resouce", assetResponse);
154 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
155 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
157 List<String> variables = Arrays.asList(resourceKey, categoryFilterKey, "NotExistingCategory");
158 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
160 /*// Validate audit message
161 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES)*/;
164 @Test // (enabled = false)
165 public void getResourceAssetSubCategoryNotExists() throws Exception {
166 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory(), subCategoryFilterKey + "=" + "NotExistingSubCategory" };
168 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
169 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY.name());
171 assertNotNull("check response object is not null after create resouce", assetResponse);
172 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
173 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
175 List<String> variables = Arrays.asList("Resource", "NotExistingSubCategory", ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory());
176 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY.name(), variables, assetResponse.getResponse());
178 /*// Validate audit message
179 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
182 @Test // (enabled = false)
183 public void getResourceAssetCategoryNotExistsSubCategoryExists() throws Exception {
184 String[] filter = { subCategoryFilterKey + "=" + ResourceCategoryEnum.NETWORK_L2_3_GETEWAY.getSubCategory(), categoryFilterKey + "=" + "NotExistingCategory" };
186 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
187 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
189 assertNotNull("check response object is not null after create resouce", assetResponse);
190 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
191 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
193 List<String> variables = Arrays.asList(resourceKey, categoryFilterKey, "NotExistingCategory");
194 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
196 /*// Validate audit message
197 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
200 @Test // (enabled = false)
201 public void getResourceAssetInvalidFilterKey() throws Exception {
202 String[] filter = { subCategoryFilterKey + "1=" + ResourceCategoryEnum.NETWORK_L2_3_GETEWAY.getSubCategory(), categoryFilterKey + "=" + "NotExistingCategory" };
204 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
205 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FILTER_KEY.name());
207 assertNotNull("check response object is not null after create resouce", assetResponse);
208 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
209 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
211 List<String> variables = Arrays.asList(subCategoryFilterKey + "1", validFilterParameters);
212 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FILTER_KEY.name(), variables, assetResponse.getResponse());
214 /*// Validate audit message
215 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
218 // ---------------------------------------------------------------------------------------------------------
221 @Test // (enabled = false)
222 public void getServiceAssetBySpecifiedCategory() throws Exception {
223 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue() };
224 List<String> expectedAssetNamesList = new ArrayList<>();
226 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
227 expectedAssetNamesList.add(service1.getName());
229 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
230 BaseRestUtils.checkSuccess(assetResponse);
232 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
233 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
234 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
236 /*// Validate audit message
237 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
240 @Test // (enabled = false)
241 public void getServiceAssetBySpecifiedCategoryAndDistributionStatus() throws Exception {
242 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue(), distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED };
243 List<String> expectedAssetNamesList = new ArrayList<>();
244 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
246 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
247 expectedAssetNamesList.add(service1.getName());
248 Service service2 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
249 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service2.getUniqueId());
250 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
251 service2 = (Service) AtomicOperationUtils.changeComponentState(service2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
252 expectedAssetNamesList.add(service2.getName());
254 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
255 BaseRestUtils.checkSuccess(assetResponse);
257 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
258 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
259 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
261 /*// Validate audit message
262 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
265 @Test // (enabled = false)
266 public void getServiceAssetByDistributionStatus() throws Exception {
267 String[] filter = { distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED };
268 List<String> expectedAssetNamesList = new ArrayList<>();
269 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
271 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
272 expectedAssetNamesList.add(service1.getName());
273 Service service2 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
274 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service2.getUniqueId());
275 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
276 service2 = (Service) AtomicOperationUtils.changeComponentState(service2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
277 ServiceRestUtils.approveServiceDistribution(service2.getUniqueId(), UserRoleEnum.GOVERNOR.getUserId());
279 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
280 BaseRestUtils.checkSuccess(assetResponse);
282 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
283 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
284 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
286 /*// Validate audit message
287 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
291 @Test // (enabled = false)
292 public void getServiceAssetCategoryNotExists() throws Exception {
293 String[] filter = { categoryFilterKey + "=" + "NotExistingCategory" };
295 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
296 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
298 assertNotNull("check response object is not null after create resouce", assetResponse);
299 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
300 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
302 List<String> variables = Arrays.asList(serviceKey, categoryFilterKey, "NotExistingCategory");
303 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
305 /*// Validate audit message
306 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
309 @Test // (enabled = false)
310 public void getServiceAssetInvalidDistributionStatus() throws Exception {
311 String[] filter = { distributionStatusFilterKey + "=" + "NotExistingDistributionStatus" };
312 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
313 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
315 assertNotNull("check response object is not null after create resouce", assetResponse);
316 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
317 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
319 List<String> variables = Arrays.asList(serviceKey, distributionStatusFilterKey, "NotExistingDistributionStatus");
320 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
322 /*// Validate audit message
323 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
326 @Test // (enabled = false)
327 public void getServiceAssetCategoryExitsDistributionStatusInvalid() throws Exception {
328 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue(), distributionStatusFilterKey + "=" + "NotExistingDistributionStatus" };
330 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
331 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
333 assertNotNull("check response object is not null after create resouce", assetResponse);
334 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
335 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
337 List<String> variables = Arrays.asList(serviceKey, distributionStatusFilterKey, "NotExistingDistributionStatus");
338 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
340 /*// Validate audit message
341 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
344 @Test // (enabled = false)
345 public void getServiceAssetCategoryNotExistsDistributionStatus() throws Exception {
346 String[] filter = { distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, categoryFilterKey + "=" + "NotExistingCategory" };
348 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
349 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
351 assertNotNull("check response object is not null after create resouce", assetResponse);
352 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
353 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
355 List<String> variables = Arrays.asList(serviceKey, categoryFilterKey, "NotExistingCategory");
356 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
358 /*// Validate audit message
359 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
362 @Test // (enabled = false)
363 public void getServiceAssetInvalidFilterKey() throws Exception {
364 String[] filter = { distributionStatusFilterKey + "1=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue() };
366 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
367 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FILTER_KEY.name());
369 assertNotNull("check response object is not null after create resouce", assetResponse);
370 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
371 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
373 List<String> variables = Arrays.asList(distributionStatusFilterKey + "1", "[" + categoryFilterKey + ", " + distributionStatusFilterKey + "]");
374 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FILTER_KEY.name(), variables, assetResponse.getResponse());
376 /*// Validate audit message
377 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
382 public void getFilteredResourceAssetCategoryNotFound() throws Exception {
384 String query = "category=Application%20L3%2B";
385 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
386 BaseRestUtils.checkErrorResponse(assetResponse, ActionStatus.COMPONENT_CATEGORY_NOT_FOUND, "resource", "category", "Application L3+");
388 /*// Validate audit message
389 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getFilteredAssetListAuditCategoryNotFound(AssetTypeEnum.RESOURCES, "?" + query, "Application L3+");
390 Map <AuditingFieldsKey, String> body = new HashMap<>();
391 body.put(AuditingFieldsKey.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
392 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);*/
397 public void getFilteredResourceAssetSuccess() throws Exception {
399 List<String> expectedAssetNamesList = new ArrayList<>();
401 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_APP_SERVER);
402 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
403 Resource resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
404 expectedAssetNamesList.add(resource.getName());
406 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_BORDER);
407 resourceDetails.setResourceType(ResourceTypeEnum.VFC.name());
408 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
409 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
410 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
411 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
412 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
414 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.GENERIC_INFRASTRUCTURE);
415 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
416 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
417 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
418 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
419 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
421 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_FIREWALL);
422 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
423 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
424 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
425 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
426 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
427 expectedAssetNamesList.add(resource.getName());
429 log.debug("4 resources created");
430 String query = "category=Application%20L4%2B";
431 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
432 BaseRestUtils.checkSuccess(assetResponse);
434 List<ResourceAssetStructure> resourceAssetList = AssetRestUtils.getResourceAssetList(assetResponse);
435 List<String> getActualAssetNamesList = AssetRestUtils.getResourceNamesList(resourceAssetList);
436 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
438 // Andrey L. This condition can not be checked in case resources list has two or ore different resource types
439 // AssetRestUtils.checkResourceTypeInObjectList(resourceAssetList, ResourceTypeEnum.VF);
441 /*// Validate audit message
442 validateFilteredAudit(query, AssetTypeEnum.RESOURCES);*/
447 public void getFilteredServiceAssetInformationalSuccess() throws Exception {
449 List<String> expectedAssetNamesList = new ArrayList<>();
450 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
451 artifactDetails.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL.getType());
453 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
454 Service service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
456 serviceDetails = ElementFactory.getDefaultService();
457 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
458 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
459 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
460 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
462 ServiceReqDetails certifyService = new ServiceReqDetails(service);
463 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
464 AtomicOperationUtils.distributeService(service, false);
465 expectedAssetNamesList.add(service.getName());
467 serviceDetails = ElementFactory.getDefaultService();
468 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
469 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
470 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
471 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
472 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
473 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
474 certifyService = new ServiceReqDetails(service);
475 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
476 AtomicOperationUtils.distributeService(service, false);
477 expectedAssetNamesList.add(service.getName());
479 serviceDetails = ElementFactory.getDefaultService();
480 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
481 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
482 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
483 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
484 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
485 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
487 serviceDetails = ElementFactory.getDefaultService();
488 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
489 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
490 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
491 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
492 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
494 String query = "distributionStatus=Distributed";
495 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.SERVICES, query);
496 BaseRestUtils.checkSuccess(assetResponse);
498 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
499 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
500 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
505 public void getFilteredServiceAssetDeploymentSuccess() throws Exception {
507 List<String> expectedAssetNamesList = new ArrayList<>();
508 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
510 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
511 Service service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
513 serviceDetails = ElementFactory.getDefaultService();
514 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
515 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
516 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
517 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
519 ServiceReqDetails certifyService = new ServiceReqDetails(service);
520 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTED);
521 AtomicOperationUtils.distributeService(service, false);
522 expectedAssetNamesList.add(service.getName());
524 serviceDetails = ElementFactory.getDefaultService();
525 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
526 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
527 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
528 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
529 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
530 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
531 certifyService = new ServiceReqDetails(service);
532 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTED);
533 AtomicOperationUtils.distributeService(service, false);
534 expectedAssetNamesList.add(service.getName());
536 serviceDetails = ElementFactory.getDefaultService();
537 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
538 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
539 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
540 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
541 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
542 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
544 serviceDetails = ElementFactory.getDefaultService();
545 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
546 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
547 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
548 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
549 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
551 String query = "distributionStatus=Distributed";
552 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.SERVICES, query);
553 BaseRestUtils.checkSuccess(assetResponse);
555 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
556 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
557 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
559 /*// Validate audit message
560 validateFilteredAudit(query, AssetTypeEnum.SERVICES);*/
563 /*private void validateSuccessAudit(String[] filter, AssetTypeEnum assetType) throws Exception {
564 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultAssetListAudit(assetType, AuditingActionEnum.GET_FILTERED_ASSET_LIST);
565 expectedAssetListAudit.setRESOURCE_URL(AssetRestUtils.buildUrlWithFilter(expectedAssetListAudit.getRESOURCE_URL(), filter));
566 Map<AuditingFieldsKey, String> body = new HashMap<>();
567 body.put(AuditingFieldsKey.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
568 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
571 private void validateFilteredAudit(String query, AssetTypeEnum assetType) throws Exception {
572 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultFilteredAssetListAudit(assetType, "?" + query);
573 Map<AuditingFieldsKey, String> body = new HashMap<>();
574 body.put(AuditingFieldsKey.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
575 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
578 private void validateFailureAudit(String[] filter, ErrorInfo errorInfo, List<String> variables, AssetTypeEnum assetType) throws Exception {
579 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultAssetListAudit(assetType, AuditingActionEnum.GET_FILTERED_ASSET_LIST);
580 expectedAssetListAudit.setRESOURCE_URL(AssetRestUtils.buildUrlWithFilter(expectedAssetListAudit.getRESOURCE_URL(), filter));
581 expectedAssetListAudit.setSTATUS(errorInfo.getCode().toString());
582 expectedAssetListAudit.setDESC(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
583 Map<AuditingFieldsKey, String> body = new HashMap<>();
584 body.put(AuditingFieldsKey.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
585 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);