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.ci.tests.execute.product;
23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_MISSING_INFORMATION;
24 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_NOT_FOUND;
25 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION;
26 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS_DELETE;
27 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_UNSUPPORTED_ERROR;
28 import static org.testng.AssertJUnit.assertEquals;
29 import static org.testng.AssertJUnit.assertTrue;
31 import java.util.ArrayList;
32 import java.util.List;
34 import org.junit.Rule;
35 import org.junit.rules.TestName;
36 import org.openecomp.sdc.be.dao.api.ActionStatus;
37 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
38 import org.openecomp.sdc.be.model.ComponentInstance;
39 import org.openecomp.sdc.be.model.LifecycleStateEnum;
40 import org.openecomp.sdc.be.model.Product;
41 import org.openecomp.sdc.be.model.Service;
42 import org.openecomp.sdc.be.model.User;
43 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
44 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
45 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
46 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
47 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
48 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
49 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
50 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
51 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
52 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
53 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
54 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
55 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
56 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
57 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
58 import org.testng.annotations.BeforeMethod;
59 import org.testng.annotations.Test;
61 public class ChangeServiceInstanceVersionTest extends ComponentInstanceBaseTest {
63 protected ArtifactReqDetails heatArtifactDetails;
64 public String firstVfInstanceUniqueId;
65 public String firstVfInstanceName;
66 public String secondVfInstanceUniqueId;
67 public String secoundVfInstanceName;
68 public String serviceInstanceToReplaceUniqueId;
69 public String expectedServiceName;
70 public String expectedPosX;
71 public String expectedPosY;
72 public String actualServiceInstanceName;
73 public String actualPosX;
74 public String actualPosY;
77 public static TestName name = new TestName();
79 public ChangeServiceInstanceVersionTest() {
80 super(name, ChangeServiceInstanceVersionTest.class.getName());
84 public void before() throws Exception {
85 firstVfInstanceName = null;
86 secoundVfInstanceName = null;
87 firstVfInstanceUniqueId = null;
88 secondVfInstanceUniqueId = null;
89 serviceInstanceToReplaceUniqueId = null;
90 expectedServiceName = null;
93 actualServiceInstanceName = null;
100 private void createComponents() throws Exception {
101 heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
102 createAtomicResource(resourceDetailsVFC_01);
103 changeResourceStateToCertified(resourceDetailsVFC_01);
104 createAtomicResource(resourceDetailsCP_01);
105 changeResourceStateToCertified(resourceDetailsCP_01);
106 createAtomicResource(resourceDetailsVL_01);
107 changeResourceStateToCertified(resourceDetailsVL_01);
108 createAtomicResource(resourceDetailsVFC_02);
109 changeResourceStateToCertified(resourceDetailsVFC_02);
110 createAtomicResource(resourceDetailsCP_02);
111 changeResourceStateToCertified(resourceDetailsCP_02);
112 createAtomicResource(resourceDetailsVL_02);
113 changeResourceStateToCertified(resourceDetailsVL_02);
114 createVF(resourceDetailsVF_02);
115 createVF(resourceDetailsVF_01);
116 // create check-In services
117 createService(serviceDetails_01);
118 createService(serviceDetails_02);
119 createService(serviceDetails_03);
120 createProduct(productDetails_01);
121 createProduct(productDetails_02);
123 // add resourceDetailsCP_01 ,resourceDetailsVFC_01 and
124 // resourceDetailsCP_01 to resourceDetailsVF_01 and certify
125 // resourceDetailsVF_01
126 certifyVf(resourceDetailsVF_01, resourceDetailsVFC_02, resourceDetailsCP_01);
127 // add resourceDetailsCP_02 ,resourceDetailsVFC_02 and
128 // resourceDetailsVL_02 to resourceDetailsVF_02 and certify
129 // resourceDetailsVF_02
130 certifyVf(resourceDetailsVF_02, resourceDetailsVFC_02, resourceDetailsCP_02);
131 RestResponse createVFInstanceResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_01,
132 sdncDesignerDetails); // serviceDetails_01 has certified
133 // resourceDetailsVF_01
134 firstVfInstanceName = ResponseParser.getNameFromResponse(createVFInstanceResponse);
135 createVFInstanceResponse = createVFInstanceDuringSetup(serviceDetails_02, resourceDetailsVF_02,
136 sdncDesignerDetails); // serviceDetails_01 has certified
137 // resourceDetailsVF_02
138 secoundVfInstanceName = ResponseParser.getUniqueIdFromResponse(createVFInstanceResponse);
139 RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
140 LifeCycleStatesEnum.CHECKIN);
141 ResourceRestUtils.checkSuccess(restResponse);
142 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails,
143 LifeCycleStatesEnum.CHECKIN);
144 ResourceRestUtils.checkSuccess(restResponse);
148 public void changeServiceInstanceVersionByPm() throws Exception {
149 // Adding service instance (serviceDetails_01) to product without saving
151 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
153 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
154 String firstServiceInstanceNormalizedName = ResponseParser
155 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
156 // Adding service instance (serviceDetails_02) to product AND ---> Save
158 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
159 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
161 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
162 LifeCycleStatesEnum.CHECKIN);
163 ProductRestUtils.checkSuccess(changeStatusResponse);
164 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
165 // Checkout service [0.2]
166 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
167 LifeCycleStatesEnum.CHECKOUT);
168 ResourceRestUtils.checkSuccess(changeStatusResponse);
169 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
170 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
171 // get the new VF instance uniqueId after checkout service
172 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
173 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
174 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
175 for (ComponentInstance component : serviceComponentInstances) {
176 if (component.getName().equals(firstVfInstanceName)) {
177 firstVfInstanceUniqueId = component.getUniqueId();
180 assertTrue(firstVfInstanceUniqueId != null);
181 // delete resource instance (resourceDetailsVF_01) from Service
182 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
183 serviceDetails_01, sdncDesignerDetails);
184 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
185 // Add different VF instance (resourceDetailsVF_02) to Service
186 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
187 sdncDesignerDetails);
188 ResourceRestUtils.checkCreateResponse(restResponse);
189 // Check-In service [0.2]
190 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
191 LifeCycleStatesEnum.CHECKIN);
192 ResourceRestUtils.checkSuccess(changeStatusResponse);
194 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
195 LifeCycleStatesEnum.CHECKOUT);
196 ProductRestUtils.checkSuccess(changeStatusResponse);
197 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
198 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
199 // get service instance new uniqueId , name and position after checkout
201 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
202 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
203 List<ComponentInstance> componentInstances = product.getComponentInstances();
204 for (ComponentInstance component : componentInstances) {
205 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
206 serviceInstanceToReplaceUniqueId = component.getUniqueId();
207 expectedServiceName = component.getName();
208 expectedPosX = component.getPosX();
209 expectedPosY = component.getPosY();
212 assertTrue(serviceInstanceToReplaceUniqueId != null);
213 // change service instance to newer version
214 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
215 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
216 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
217 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
218 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
220 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
222 ComponentInstance componentInstance = ResponseParser
223 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
224 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
226 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
227 LifeCycleStatesEnum.CHECKIN);
228 ProductRestUtils.checkSuccess(changeStatusResponse);
229 getComponentAndValidateRIs(productDetails_01, 2, 0);
230 // Verify that Service instance name and position didn't change after
231 // changing service instance version
232 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
233 assertTrue(actualPosX.equals(expectedPosX));
234 assertTrue(actualPosY.equals(expectedPosY));
238 public void changeServiceInstanceVersionByAdmin() throws Exception {
239 // Adding service instance (serviceDetails_01) to product without saving
241 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
243 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
244 String firstServiceInstanceNormalizedName = ResponseParser
245 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
246 // Adding service instance (serviceDetails_02) to product AND ---> Save
248 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
249 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
251 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
252 LifeCycleStatesEnum.CHECKIN);
253 ProductRestUtils.checkSuccess(changeStatusResponse);
254 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
255 // Checkout service [0.2]
256 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
257 LifeCycleStatesEnum.CHECKOUT);
258 ResourceRestUtils.checkSuccess(changeStatusResponse);
259 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
260 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
261 // get the new VF instance uniqueId after checkout service
262 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
263 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
264 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
265 for (ComponentInstance component : serviceComponentInstances) {
266 if (component.getName().equals(firstVfInstanceName)) {
267 firstVfInstanceUniqueId = component.getUniqueId();
270 assertTrue(firstVfInstanceUniqueId != null);
271 // delete resource instance (resourceDetailsVF_01) from Service
272 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
273 serviceDetails_01, sdncDesignerDetails);
274 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
275 // Add different VF instance (resourceDetailsVF_02) to Service
276 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
277 sdncDesignerDetails);
278 ResourceRestUtils.checkCreateResponse(restResponse);
279 // service [0.2] state to CERTIFICATIONREQUEST
280 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
281 LifeCycleStatesEnum.CHECKIN);
282 ResourceRestUtils.checkSuccess(changeStatusResponse);
283 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
284 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
285 ResourceRestUtils.checkSuccess(changeStatusResponse);
286 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
287 LifeCycleStatesEnum.STARTCERTIFICATION);
288 ResourceRestUtils.checkSuccess(changeStatusResponse);
290 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails,
291 LifeCycleStatesEnum.CHECKOUT);
292 ProductRestUtils.checkSuccess(changeStatusResponse);
293 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
294 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
295 // get service instance new uniqueId , name and position after checkout
297 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
298 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
299 List<ComponentInstance> componentInstances = product.getComponentInstances();
300 for (ComponentInstance component : componentInstances) {
301 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
302 serviceInstanceToReplaceUniqueId = component.getUniqueId();
303 expectedServiceName = component.getName();
304 expectedPosX = component.getPosX();
305 expectedPosY = component.getPosY();
308 assertTrue(serviceInstanceToReplaceUniqueId != null);
309 // change service instance to newer version
310 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
311 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncAdminDetails, ComponentTypeEnum.PRODUCT,
313 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
314 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
315 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
317 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
319 ComponentInstance componentInstance = ResponseParser
320 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
321 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
323 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails,
324 LifeCycleStatesEnum.CHECKIN);
325 ProductRestUtils.checkSuccess(changeStatusResponse);
326 getComponentAndValidateRIs(productDetails_01, 2, 0);
327 // Verify that Service instance name and position didn't change after
328 // changing service instance version
329 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
330 assertTrue(actualPosX.equals(expectedPosX));
331 assertTrue(actualPosY.equals(expectedPosY));
335 public void changeServiceInstanceToOlderVersion() throws Exception {
336 // Get VF Instance UniquId [Service version 0.1]
337 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
338 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
339 ComponentInstance actualComponentInstance = service.getComponentInstances().get(0);
340 firstVfInstanceUniqueId = actualComponentInstance.getUniqueId();
341 String serviceOlderVersionUniquId = ResponseParser.getUniqueIdFromResponse(getServiceResponse);
343 // Checkout service [0.2]
344 RestResponse changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01,
345 sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
346 ResourceRestUtils.checkSuccess(changeStatusResponse);
347 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
348 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
349 // get the new VF instance uniqueId after checkout service
350 getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
351 service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
352 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
353 for (ComponentInstance component : serviceComponentInstances) {
354 if (component.getName().equals(firstVfInstanceName)) {
355 firstVfInstanceUniqueId = component.getUniqueId();
358 assertTrue(firstVfInstanceUniqueId != null);
359 // delete resource instance (resourceDetailsVF_01) from Service
360 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
361 serviceDetails_01, sdncDesignerDetails);
362 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
363 // Add different VF instance (resourceDetailsVF_02) to Service
364 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
365 sdncDesignerDetails);
366 ResourceRestUtils.checkCreateResponse(restResponse);
367 // Check-In service [0.2]
368 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
369 LifeCycleStatesEnum.CHECKIN);
370 ResourceRestUtils.checkSuccess(changeStatusResponse);
371 // Adding service instance (serviceDetails_01 V0.2) to product without
373 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
375 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
376 String firstServiceInstanceNormalizedName = ResponseParser
377 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
378 // Adding service instance (serviceDetails_02) to product AND ---> Save
380 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
381 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
383 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
384 LifeCycleStatesEnum.CHECKIN);
385 ProductRestUtils.checkSuccess(changeStatusResponse);
386 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
388 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
389 LifeCycleStatesEnum.CHECKOUT);
390 ProductRestUtils.checkSuccess(changeStatusResponse);
391 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
392 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
393 // get service instance new uniqueId , name and position after checkout
395 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
396 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
397 List<ComponentInstance> componentInstances = product.getComponentInstances();
398 for (ComponentInstance component : componentInstances) {
399 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
400 serviceInstanceToReplaceUniqueId = component.getUniqueId();
401 expectedServiceName = component.getName();
402 expectedPosX = component.getPosX();
403 expectedPosY = component.getPosY();
406 assertTrue(serviceInstanceToReplaceUniqueId != null);
407 // change service instance to Older version
408 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
409 serviceInstanceToReplaceUniqueId, serviceOlderVersionUniquId, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
411 // RestResponse changeServiceInstanceVersionResponse =
412 // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
413 // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
414 // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
415 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
416 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
417 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
419 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
421 ComponentInstance componentInstance = ResponseParser
422 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
423 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
425 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
426 LifeCycleStatesEnum.CHECKIN);
427 ProductRestUtils.checkSuccess(changeStatusResponse);
428 getComponentAndValidateRIs(productDetails_01, 2, 0);
429 // Verify that Service instance name and position didn't change after
430 // changing service instance version
431 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
432 assertTrue(actualPosX.equals(expectedPosX));
433 assertTrue(actualPosY.equals(expectedPosY));
438 public void changeServiceInstanceVersionToCertifiedVersion() throws Exception {
439 // Adding service instance (serviceDetails_01) to product without saving
441 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
443 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
444 String firstServiceInstanceNormalizedName = ResponseParser
445 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
446 // Adding service instance (serviceDetails_02) to product AND ---> Save
448 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
449 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
451 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
452 LifeCycleStatesEnum.CHECKIN);
453 ProductRestUtils.checkSuccess(changeStatusResponse);
454 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
455 // Checkout service [0.2]
456 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
457 LifeCycleStatesEnum.CHECKOUT);
458 ResourceRestUtils.checkSuccess(changeStatusResponse);
460 * String serviceNewUniqueUid =
461 * ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
462 * serviceDetails_01.setUniqueId(serviceNewUniqueUid);
464 // get the new VF instance uniqueId after checkout service
465 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
466 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
467 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
468 for (ComponentInstance component : serviceComponentInstances) {
469 if (component.getName().equals(firstVfInstanceName)) {
470 firstVfInstanceUniqueId = component.getUniqueId();
473 assertTrue(firstVfInstanceUniqueId != null);
474 // delete resource instance (resourceDetailsVF_01) from Service
475 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
476 serviceDetails_01, sdncDesignerDetails);
477 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
478 // Add different VF instance (resourceDetailsVF_02) to Service
479 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
480 sdncDesignerDetails);
481 ResourceRestUtils.checkCreateResponse(restResponse);
482 // Check-In service [0.2]
483 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
484 LifeCycleStatesEnum.CHECKIN);
485 ResourceRestUtils.checkSuccess(changeStatusResponse);
486 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
487 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
488 ResourceRestUtils.checkSuccess(changeStatusResponse);
489 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
490 LifeCycleStatesEnum.STARTCERTIFICATION);
491 ResourceRestUtils.checkSuccess(changeStatusResponse);
492 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
493 LifeCycleStatesEnum.CERTIFY);
494 ResourceRestUtils.checkSuccess(changeStatusResponse);
495 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
497 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
498 LifeCycleStatesEnum.CHECKOUT);
499 ProductRestUtils.checkSuccess(changeStatusResponse);
500 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
501 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
502 // get service instance new uniqueId , name and position after checkout
504 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
505 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
506 List<ComponentInstance> componentInstances = product.getComponentInstances();
507 for (ComponentInstance component : componentInstances) {
508 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
509 serviceInstanceToReplaceUniqueId = component.getUniqueId();
510 expectedServiceName = component.getName();
511 expectedPosX = component.getPosX();
512 expectedPosY = component.getPosY();
515 assertTrue(serviceInstanceToReplaceUniqueId != null);
516 // change service instance to newer version
517 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
518 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
519 // RestResponse changeServiceInstanceVersionResponse =
520 // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
521 // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
522 // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
523 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
524 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
525 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
527 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
529 ComponentInstance componentInstance = ResponseParser
530 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
531 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
533 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
534 LifeCycleStatesEnum.CHECKIN);
535 ProductRestUtils.checkSuccess(changeStatusResponse);
536 getComponentAndValidateRIs(productDetails_01, 2, 0);
537 // Verify that Service instance name and position didn't change after
538 // changing service instance version
539 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
540 assertTrue(actualPosX.equals(expectedPosX));
541 assertTrue(actualPosY.equals(expectedPosY));
545 @Test(enabled = false)
546 public void changeServiceInstanceVersionThenReCheckInProduct() throws Exception {
547 // Adding service instance (serviceDetails_01) to product without saving
549 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
551 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
552 String firstServiceInstanceNormalizedName = ResponseParser
553 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
554 // Adding service instance (serviceDetails_02) to product AND ---> Save
556 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
557 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
559 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
560 LifeCycleStatesEnum.CHECKIN);
561 ProductRestUtils.checkSuccess(changeStatusResponse);
562 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
563 // Checkout service [0.2]
564 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
565 LifeCycleStatesEnum.CHECKOUT);
566 ResourceRestUtils.checkSuccess(changeStatusResponse);
567 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
568 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
569 // get the new VF instance uniqueId after checkout service
570 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
571 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
572 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
573 for (ComponentInstance component : serviceComponentInstances) {
574 if (component.getName().equals(firstVfInstanceName)) {
575 firstVfInstanceUniqueId = component.getUniqueId();
578 assertTrue(firstVfInstanceUniqueId != null);
579 // delete resource instance (resourceDetailsVF_01) from Service
580 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
581 serviceDetails_01, sdncDesignerDetails);
582 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
583 // Add different VF instance (resourceDetailsVF_02) to Service
584 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
585 sdncDesignerDetails);
586 ResourceRestUtils.checkCreateResponse(restResponse);
587 // Check-In service [0.2]
588 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
589 LifeCycleStatesEnum.CHECKIN);
590 ResourceRestUtils.checkSuccess(changeStatusResponse);
592 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
593 LifeCycleStatesEnum.CHECKOUT);
594 ProductRestUtils.checkSuccess(changeStatusResponse);
595 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
596 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
597 // get service instance new uniqueId , name and position after checkout
599 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
600 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
601 List<ComponentInstance> componentInstances = product.getComponentInstances();
602 for (ComponentInstance component : componentInstances) {
603 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
604 serviceInstanceToReplaceUniqueId = component.getUniqueId();
605 expectedServiceName = component.getName();
606 expectedPosX = component.getPosX();
607 expectedPosY = component.getPosY();
610 assertTrue(serviceInstanceToReplaceUniqueId != null);
611 // change service instance to newer version
612 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
613 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
614 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
615 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
616 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
618 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
620 ComponentInstance componentInstance = ResponseParser
621 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
622 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
624 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
625 LifeCycleStatesEnum.CHECKIN);
626 ProductRestUtils.checkSuccess(changeStatusResponse);
627 /////////////////////
628 productOldUniqueId = productDetails_01.getUniqueId();
629 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
630 LifeCycleStatesEnum.CHECKOUT);
631 ProductRestUtils.checkSuccess(changeStatusResponse);
633 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
634 LifeCycleStatesEnum.CHECKIN);
635 ProductRestUtils.checkSuccess(changeStatusResponse);
636 productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
637 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
638 /////////////////////////////////////////////
639 getComponentAndValidateRIs(productDetails_01, 2, 0);
640 // Verify that Service instance name and position didn't change after
641 // changing service instance version
642 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
643 assertTrue(actualPosX.equals(expectedPosX));
644 assertTrue(actualPosY.equals(expectedPosY));
648 public void changeServiceInstanceToHisVersion() throws Exception {
649 // Get VF Instance UniquId [Service version 0.1]
650 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
651 String serviceOlderVersionUniquId = ResponseParser.getUniqueIdFromResponse(getServiceResponse);
652 // Adding service instance (serviceDetails_01) to product without saving
654 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
656 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
657 String firstServiceInstanceNormalizedName = ResponseParser
658 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
659 // Adding service instance (serviceDetails_02) to product AND ---> Save
661 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
662 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
664 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
665 LifeCycleStatesEnum.CHECKIN);
666 ProductRestUtils.checkSuccess(changeStatusResponse);
667 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
668 // Checkout service [0.2]
669 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
670 LifeCycleStatesEnum.CHECKOUT);
671 ResourceRestUtils.checkSuccess(changeStatusResponse);
672 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
673 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
674 // get the new VF instance uniqueId after checkout service
675 getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
676 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
677 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
678 for (ComponentInstance component : serviceComponentInstances) {
679 if (component.getName().equals(firstVfInstanceName)) {
680 firstVfInstanceUniqueId = component.getUniqueId();
683 assertTrue(firstVfInstanceUniqueId != null);
684 // delete resource instance (resourceDetailsVF_01) from Service
685 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
686 serviceDetails_01, sdncDesignerDetails);
687 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
688 // Add different VF instance (resourceDetailsVF_02) to Service
689 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
690 sdncDesignerDetails);
691 ResourceRestUtils.checkCreateResponse(restResponse);
692 // Check-In service [0.2]
693 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
694 LifeCycleStatesEnum.CHECKIN);
695 ResourceRestUtils.checkSuccess(changeStatusResponse);
697 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
698 LifeCycleStatesEnum.CHECKOUT);
699 ProductRestUtils.checkSuccess(changeStatusResponse);
700 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
701 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
702 // get service instance new uniqueId , name and position after checkout
704 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
705 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
706 List<ComponentInstance> componentInstances = product.getComponentInstances();
707 for (ComponentInstance component : componentInstances) {
708 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
709 serviceInstanceToReplaceUniqueId = component.getUniqueId();
710 expectedServiceName = component.getName();
711 expectedPosX = component.getPosX();
712 expectedPosY = component.getPosY();
715 assertTrue(serviceInstanceToReplaceUniqueId != null);
716 // change service instance to newer version
717 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
718 serviceInstanceToReplaceUniqueId, serviceOlderVersionUniquId, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
720 // RestResponse changeServiceInstanceVersionResponse =
721 // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
722 // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
723 // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
724 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
725 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
726 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
728 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
730 ComponentInstance componentInstance = ResponseParser
731 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
732 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
734 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
735 LifeCycleStatesEnum.CHECKIN);
736 ProductRestUtils.checkSuccess(changeStatusResponse);
737 getComponentAndValidateRIs(productDetails_01, 2, 0);
738 // Verify that Service instance name and position didn't change after
739 // changing service instance version
740 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
741 assertTrue(actualPosX.equals(expectedPosX));
742 assertTrue(actualPosY.equals(expectedPosY));
746 public void changeServiceInstanceVersionByAdminNotByProductOwner() throws Exception {
747 // Adding service instance (serviceDetails_01) to product without saving
749 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
751 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
752 // Adding service instance (serviceDetails_02) to product AND ---> Save
754 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
755 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
757 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
758 LifeCycleStatesEnum.CHECKIN);
759 ProductRestUtils.checkSuccess(changeStatusResponse);
760 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
761 // Checkout service [0.2]
762 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
763 LifeCycleStatesEnum.CHECKOUT);
764 ResourceRestUtils.checkSuccess(changeStatusResponse);
765 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
766 // Check-In service [0.2]
767 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
768 LifeCycleStatesEnum.CHECKIN);
769 ResourceRestUtils.checkSuccess(changeStatusResponse);
771 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
772 LifeCycleStatesEnum.CHECKOUT);
773 ProductRestUtils.checkSuccess(changeStatusResponse);
774 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
775 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
777 // change service instance to newer version
778 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
779 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncAdminDetails, ComponentTypeEnum.PRODUCT,
781 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
782 changeServiceInstanceVersionResponse.getErrorCode().intValue());
783 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
784 changeServiceInstanceVersionResponse.getResponse());
786 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
787 LifeCycleStatesEnum.CHECKIN);
788 ProductRestUtils.checkSuccess(changeStatusResponse);
789 getComponentAndValidateRIs(productDetails_01, 2, 0);
794 public void changeServiceInstanceVersionByPmNotByProductOwner() throws Exception {
795 // Adding service instance (serviceDetails_01) to product AND --->
797 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
799 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
800 // Adding service instance (serviceDetails_02) to product AND ---> Save
802 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
803 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
805 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
806 LifeCycleStatesEnum.CHECKIN);
807 ProductRestUtils.checkSuccess(changeStatusResponse);
808 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
809 // Checkout service [0.2]
810 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
811 LifeCycleStatesEnum.CHECKOUT);
812 ResourceRestUtils.checkSuccess(changeStatusResponse);
813 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
814 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
815 // Check-In service [0.2]
816 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
817 LifeCycleStatesEnum.CHECKIN);
818 ResourceRestUtils.checkSuccess(changeStatusResponse);
820 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
821 LifeCycleStatesEnum.CHECKOUT);
822 ProductRestUtils.checkSuccess(changeStatusResponse);
823 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
824 // change uniqueId after product check-out in expected Req&Cap
825 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
826 updateNewComponentInstanceId(createServiceInstanceResp, productNewUniqueId);
827 // CHANGE Service Instance VERSION BY NON PRODUCT OWNER (sdncPmDetails1
828 // instead sdncPmDetails1)
829 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
830 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails2,
831 ComponentTypeEnum.PRODUCT, true);
832 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
833 changeServiceInstanceVersionResponse.getErrorCode().intValue());
834 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
835 changeServiceInstanceVersionResponse.getResponse());
837 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
838 LifeCycleStatesEnum.CHECKIN);
839 ProductRestUtils.checkSuccess(changeStatusResponse);
840 getComponentAndValidateRIs(productDetails_01, 2, 0);
844 public void changeServiceInstanceVersionByTester() throws Exception {
845 // Adding service instance (serviceDetails_01) to product AND --->
847 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
849 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
850 String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
851 // Adding service instance (serviceDetails_02) to product AND ---> Save
853 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
854 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
856 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
857 LifeCycleStatesEnum.CHECKIN);
858 ProductRestUtils.checkSuccess(changeStatusResponse);
859 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
860 // Checkout service [0.2]
861 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
862 LifeCycleStatesEnum.CHECKOUT);
863 ResourceRestUtils.checkSuccess(changeStatusResponse);
864 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
865 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
866 // Check-In service [0.2]
867 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
868 LifeCycleStatesEnum.CHECKIN);
869 ResourceRestUtils.checkSuccess(changeStatusResponse);
871 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
872 LifeCycleStatesEnum.CHECKOUT);
873 ProductRestUtils.checkSuccess(changeStatusResponse);
874 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
875 // change uniqueId after product check-out in expected Req&Cap
876 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
877 // CHANGE Service Instance VERSION BY NON PRODUCT OWNER (sdncPmDetails1
878 // instead sdncPmDetails1)
879 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
880 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid,
881 sdncTesterDetails, ComponentTypeEnum.PRODUCT, true);
882 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
883 changeServiceInstanceVersionResponse.getErrorCode().intValue());
884 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
885 changeServiceInstanceVersionResponse.getResponse());
887 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
888 LifeCycleStatesEnum.CHECKIN);
889 ProductRestUtils.checkSuccess(changeStatusResponse);
890 getComponentAndValidateRIs(productDetails_01, 2, 0);
894 public void changeServiceInstanceVersionProductIsNotCheckOut() throws Exception {
895 // Adding service instance (serviceDetails_01) to product AND --->
897 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
899 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
900 String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
901 // Adding service instance (serviceDetails_02) to product AND ---> Save
903 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
904 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
906 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
907 LifeCycleStatesEnum.CHECKIN);
908 ProductRestUtils.checkSuccess(changeStatusResponse);
909 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
910 // Checkout service [0.2]
911 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
912 LifeCycleStatesEnum.CHECKOUT);
913 ResourceRestUtils.checkSuccess(changeStatusResponse);
914 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
915 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
916 // Check-In service [0.2]
917 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
918 LifeCycleStatesEnum.CHECKIN);
919 ResourceRestUtils.checkSuccess(changeStatusResponse);
920 // CHANGE Service Instance VERSION for Non checkedOut product
921 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productOldUniqueId,
922 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
923 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
924 changeServiceInstanceVersionResponse.getErrorCode().intValue());
925 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
926 changeServiceInstanceVersionResponse.getResponse());
927 getComponentAndValidateRIs(productDetails_01, 2, 0);
931 @Test(enabled = false)
932 public void changeServiceInstanceVersionServiceIsInCheckOutState() throws Exception {
933 // Adding service instance (serviceDetails_01) to product AND --->
935 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
937 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
938 String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
939 // Adding service instance (serviceDetails_02) to product AND ---> Save
941 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
942 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
944 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
945 LifeCycleStatesEnum.CHECKIN);
946 ProductRestUtils.checkSuccess(changeStatusResponse);
947 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
948 // Checkout service [0.2]
949 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
950 LifeCycleStatesEnum.CHECKOUT);
951 ResourceRestUtils.checkSuccess(changeStatusResponse);
952 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
954 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
955 LifeCycleStatesEnum.CHECKOUT);
956 ProductRestUtils.checkSuccess(changeStatusResponse);
957 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
958 // change uniqueId after product check-out in expected Req&Cap
959 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
960 // CHANGE Service Instance VERSION to service in checkOut state
961 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
962 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1,
963 ComponentTypeEnum.PRODUCT, true);
964 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
965 changeServiceInstanceVersionResponse.getErrorCode().intValue());
966 ArrayList<String> varibales = new ArrayList<String>();
967 varibales.add(serviceNewUniqueUid);
968 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), varibales,
969 changeServiceInstanceVersionResponse.getResponse());
971 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
972 LifeCycleStatesEnum.CHECKIN);
973 ProductRestUtils.checkSuccess(changeStatusResponse);
974 getComponentAndValidateRIs(productDetails_01, 2, 0);
975 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
976 LifeCycleStatesEnum.CHECKIN);
977 ResourceRestUtils.checkSuccess(changeStatusResponse);
982 public void changeServiceInstanceVersionServiceInstanceDoesNotExist() throws Exception {
983 // Adding service instance (serviceDetails_01) to product without saving
985 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
987 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
988 // Adding service instance (serviceDetails_02) to product AND ---> Save
990 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
991 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
993 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
994 LifeCycleStatesEnum.CHECKIN);
995 ProductRestUtils.checkSuccess(changeStatusResponse);
996 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
997 // Checkout service [0.2]
998 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
999 LifeCycleStatesEnum.CHECKOUT);
1000 ResourceRestUtils.checkSuccess(changeStatusResponse);
1001 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1002 // Check-In service [0.2]
1003 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1004 LifeCycleStatesEnum.CHECKIN);
1005 ResourceRestUtils.checkSuccess(changeStatusResponse);
1006 // check-out product
1007 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1008 LifeCycleStatesEnum.CHECKOUT);
1009 ProductRestUtils.checkSuccess(changeStatusResponse);
1010 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1011 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1012 // change service instance to newer version
1013 String serviceUniqueUidNotExist = "1234567890";
1014 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1015 serviceUniqueUidNotExist, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1016 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1017 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1018 ArrayList<String> varibales = new ArrayList<String>();
1019 varibales.add(serviceUniqueUidNotExist);
1020 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND.name(), varibales,
1021 changeServiceInstanceVersionResponse.getResponse());
1023 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1024 LifeCycleStatesEnum.CHECKIN);
1025 ProductRestUtils.checkSuccess(changeStatusResponse);
1026 getComponentAndValidateRIs(productDetails_01, 2, 0);
1030 @Test(enabled = false)
1031 public void changeServiceInstanceNonExistingProduct() throws Exception {
1032 // Adding service instance (serviceDetails_01) to product saving Req&Cap
1033 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1035 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1036 // Adding service instance (serviceDetails_02) to product AND ---> Save
1038 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1039 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1041 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1042 LifeCycleStatesEnum.CHECKIN);
1043 ProductRestUtils.checkSuccess(changeStatusResponse);
1044 // Checkout service [0.2]
1045 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1046 LifeCycleStatesEnum.CHECKOUT);
1047 ResourceRestUtils.checkSuccess(changeStatusResponse);
1048 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1049 // Check-In service [0.2]
1050 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1051 LifeCycleStatesEnum.CHECKIN);
1052 ResourceRestUtils.checkSuccess(changeStatusResponse);
1053 // change service instance to newer version - Non existing Product
1054 String productNewUniqueIdNotExist = "1234567890";
1055 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueIdNotExist,
1056 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1057 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1058 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1059 ArrayList<String> varibales = new ArrayList<String>();
1060 varibales.add(productNewUniqueIdNotExist);
1061 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND.name(), varibales,
1062 changeServiceInstanceVersionResponse.getResponse());
1063 getComponentAndValidateRIs(productDetails_01, 2, 0);
1067 public void changeServiceInstanceVersionToNonExisitingServiceVersion() throws Exception {
1068 // Adding service instance (serviceDetails_01) to product saving Req&Cap
1069 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1071 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1072 // Adding service instance (serviceDetails_02) to product AND ---> Save
1074 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1075 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1077 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1078 LifeCycleStatesEnum.CHECKIN);
1079 ProductRestUtils.checkSuccess(changeStatusResponse);
1080 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1081 // check-out product
1082 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1083 LifeCycleStatesEnum.CHECKOUT);
1084 ProductRestUtils.checkSuccess(changeStatusResponse);
1085 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1086 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1087 // get service instance new uniqueId , name and position after checkout
1089 updateNewComponentInstanceId(createServiceInstanceResp, productNewUniqueId);
1090 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1091 // change service instance to Non-existing version
1092 String serviceUniqueUidNotExist = "1234567890";
1093 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1094 serviceInstanceToReplaceUniqueId, serviceUniqueUidNotExist, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
1096 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1097 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1098 ArrayList<String> varibales = new ArrayList<String>();
1099 varibales.add(serviceUniqueUidNotExist);
1100 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(), varibales,
1101 changeServiceInstanceVersionResponse.getResponse());
1102 getComponentAndValidateRIs(productDetails_01, 2, 0);
1106 public void changeServiceInstanceComponentTypeIsNotProduct() throws Exception {
1107 // Adding service instance (serviceDetails_01) to product without saving
1109 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1111 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1112 String firstServiceInstanceNormalizedName = ResponseParser
1113 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1114 // Adding service instance (serviceDetails_02) to product AND ---> Save
1116 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1117 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1119 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1120 LifeCycleStatesEnum.CHECKIN);
1121 ProductRestUtils.checkSuccess(changeStatusResponse);
1122 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1123 // Checkout service [0.2]
1124 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1125 LifeCycleStatesEnum.CHECKOUT);
1126 ResourceRestUtils.checkSuccess(changeStatusResponse);
1127 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1128 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1129 // Check-In service [0.2]
1130 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1131 LifeCycleStatesEnum.CHECKIN);
1132 ResourceRestUtils.checkSuccess(changeStatusResponse);
1133 // check-out product
1134 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1135 LifeCycleStatesEnum.CHECKOUT);
1136 ProductRestUtils.checkSuccess(changeStatusResponse);
1137 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1138 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1139 // get service instance new uniqueId , name and position after checkout
1141 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1142 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1143 List<ComponentInstance> componentInstances = product.getComponentInstances();
1144 for (ComponentInstance component : componentInstances) {
1145 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1146 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1149 assertTrue(serviceInstanceToReplaceUniqueId != null);
1150 // change service instance to newer version for NON-Component Type =
1151 // Product (e.g. service)
1152 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1153 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.SERVICE, true);
1154 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1155 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1156 ArrayList<String> varibales = new ArrayList<String>();
1158 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), varibales,
1159 changeServiceInstanceVersionResponse.getResponse());
1160 getComponentAndValidateRIs(productDetails_01, 2, 0);
1164 public void changeServiceInstanceComponentTypeNotSupported() throws Exception {
1165 // Adding service instance (serviceDetails_01) to product without saving
1167 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1169 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1170 String firstServiceInstanceNormalizedName = ResponseParser
1171 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1172 // Adding service instance (serviceDetails_02) to product AND ---> Save
1174 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1175 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1177 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1178 LifeCycleStatesEnum.CHECKIN);
1179 ProductRestUtils.checkSuccess(changeStatusResponse);
1180 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1181 // Checkout service [0.2]
1182 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1183 LifeCycleStatesEnum.CHECKOUT);
1184 ResourceRestUtils.checkSuccess(changeStatusResponse);
1185 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1186 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1187 // Check-In service [0.2]
1188 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1189 LifeCycleStatesEnum.CHECKIN);
1190 ResourceRestUtils.checkSuccess(changeStatusResponse);
1191 // check-out product
1192 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1193 LifeCycleStatesEnum.CHECKOUT);
1194 ProductRestUtils.checkSuccess(changeStatusResponse);
1195 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1196 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1197 // get service instance new uniqueId , name and position after checkout
1199 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1200 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1201 List<ComponentInstance> componentInstances = product.getComponentInstances();
1202 for (ComponentInstance component : componentInstances) {
1203 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1204 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1207 assertTrue(serviceInstanceToReplaceUniqueId != null);
1208 // change service instance to newer version for NON-Component Type =
1209 // Product (e.g. service)
1210 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1211 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1,
1212 ComponentTypeEnum.SERVICE_INSTANCE, true);
1213 assertEquals("Check response code ", STATUS_CODE_UNSUPPORTED_ERROR,
1214 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1215 ArrayList<String> varibales = new ArrayList<String>();
1216 varibales.add("null");
1217 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.UNSUPPORTED_ERROR.name(), varibales,
1218 changeServiceInstanceVersionResponse.getResponse());
1219 getComponentAndValidateRIs(productDetails_01, 2, 0);
1223 public void SeveralServiceInstanceFromSameServiceVersionChangeVersionOnlyForOneServiceInstance() throws Exception {
1224 // Adding service instance (serviceDetails_01) to product without saving
1226 RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
1228 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1229 String firstServiceInstanceNormalizedName = ResponseParser
1230 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1231 // Adding service instance (serviceDetails_02) to product AND ---> Save
1233 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1234 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1236 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1237 LifeCycleStatesEnum.CHECKIN);
1238 ProductRestUtils.checkSuccess(changeStatusResponse);
1239 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1240 // Checkout service [0.2]
1241 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1242 LifeCycleStatesEnum.CHECKOUT);
1243 ResourceRestUtils.checkSuccess(changeStatusResponse);
1244 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1245 serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1246 // get the new VF instance uniqueId after checkout service
1247 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
1248 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
1249 List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
1250 for (ComponentInstance component : serviceComponentInstances) {
1251 if (component.getName().equals(firstVfInstanceName)) {
1252 firstVfInstanceUniqueId = component.getUniqueId();
1255 assertTrue(firstVfInstanceUniqueId != null);
1256 // delete resource instance (resourceDetailsVF_01) from Service
1257 RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
1258 serviceDetails_01, sdncDesignerDetails);
1259 assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
1260 // Add different VF instance (resourceDetailsVF_02) to Service
1261 RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
1262 sdncDesignerDetails);
1263 ResourceRestUtils.checkCreateResponse(restResponse);
1264 // Check-In service [0.2]
1265 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1266 LifeCycleStatesEnum.CHECKIN);
1267 ResourceRestUtils.checkSuccess(changeStatusResponse);
1268 // check-out product
1269 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1270 LifeCycleStatesEnum.CHECKOUT);
1271 ProductRestUtils.checkSuccess(changeStatusResponse);
1272 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1273 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1274 // get service instance new uniqueId , name and position after checkout
1276 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1277 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1278 List<ComponentInstance> componentInstances = product.getComponentInstances();
1279 for (ComponentInstance component : componentInstances) {
1280 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1281 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1282 expectedServiceName = component.getName();
1283 expectedPosX = component.getPosX();
1284 expectedPosY = component.getPosY();
1287 assertTrue(serviceInstanceToReplaceUniqueId != null);
1288 // change service instance to newer version
1289 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1290 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1291 ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
1292 actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
1293 actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
1295 actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
1297 ComponentInstance componentInstance = ResponseParser
1298 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
1299 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
1301 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1302 LifeCycleStatesEnum.CHECKIN);
1303 ProductRestUtils.checkSuccess(changeStatusResponse);
1304 getComponentAndValidateRIs(productDetails_01, 2, 0);
1305 // Verify that Service instance name and position didn't change after
1306 // changing service instance version
1307 assertTrue(actualServiceInstanceName.equals(expectedServiceName));
1308 assertTrue(actualPosX.equals(expectedPosX));
1309 assertTrue(actualPosY.equals(expectedPosY));
1313 public void changeServiceInstanceVersionByNonAsdcUser() throws Exception {
1314 // Adding service instance (serviceDetails_01) to product without saving
1316 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1318 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1319 // Adding service instance (serviceDetails_02) to product AND ---> Save
1321 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1322 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1324 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1325 LifeCycleStatesEnum.CHECKIN);
1326 ProductRestUtils.checkSuccess(changeStatusResponse);
1327 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1328 // Checkout service [0.2]
1329 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1330 LifeCycleStatesEnum.CHECKOUT);
1331 ResourceRestUtils.checkSuccess(changeStatusResponse);
1332 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1333 // Check-In service [0.2]
1334 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1335 LifeCycleStatesEnum.CHECKIN);
1336 ResourceRestUtils.checkSuccess(changeStatusResponse);
1337 // check-out product
1338 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1339 LifeCycleStatesEnum.CHECKOUT);
1340 ProductRestUtils.checkSuccess(changeStatusResponse);
1341 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1342 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1343 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1344 nonAsdcUser.setUserId("bt760h");
1345 // change service instance to newer version
1346 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1347 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, nonAsdcUser, ComponentTypeEnum.PRODUCT, true);
1348 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
1349 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1350 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1351 changeServiceInstanceVersionResponse.getResponse());
1353 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1354 LifeCycleStatesEnum.CHECKIN);
1355 ProductRestUtils.checkSuccess(changeStatusResponse);
1356 getComponentAndValidateRIs(productDetails_01, 2, 0);
1360 public void changeServiceInstanceVersionEmptyUserId() throws Exception {
1361 // Adding service instance (serviceDetails_01) to product without saving
1363 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1365 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1366 // Adding service instance (serviceDetails_02) to product AND ---> Save
1368 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1369 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1371 RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1372 LifeCycleStatesEnum.CHECKIN);
1373 ProductRestUtils.checkSuccess(changeStatusResponse);
1374 String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1375 // Checkout service [0.2]
1376 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1377 LifeCycleStatesEnum.CHECKOUT);
1378 ResourceRestUtils.checkSuccess(changeStatusResponse);
1379 String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1380 // Check-In service [0.2]
1381 changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1382 LifeCycleStatesEnum.CHECKIN);
1383 ResourceRestUtils.checkSuccess(changeStatusResponse);
1384 // check-out product
1385 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1386 LifeCycleStatesEnum.CHECKOUT);
1387 ProductRestUtils.checkSuccess(changeStatusResponse);
1388 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1389 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1390 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1391 nonAsdcUser.setUserId("");
1392 // change service instance to newer version
1393 RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1394 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, nonAsdcUser, ComponentTypeEnum.PRODUCT, true);
1395 assertEquals("Check response code ", STATUS_CODE_MISSING_INFORMATION,
1396 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1397 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
1398 changeServiceInstanceVersionResponse.getResponse());
1400 changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1401 LifeCycleStatesEnum.CHECKIN);
1402 ProductRestUtils.checkSuccess(changeStatusResponse);
1403 getComponentAndValidateRIs(productDetails_01, 2, 0);
1406 ////////////////////////////////////
1407 private void updateNewComponentInstanceId(RestResponse createServiceInstanceResp, String productNewUniqueId)
1409 String firstServiceInstanceNormalizedName = ResponseParser
1410 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1411 RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1412 Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1413 List<ComponentInstance> componentInstances = product.getComponentInstances();
1414 for (ComponentInstance component : componentInstances) {
1415 if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1416 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1417 expectedServiceName = component.getName();
1418 expectedPosX = component.getPosX();
1419 expectedPosY = component.getPosY();
1422 assertTrue(serviceInstanceToReplaceUniqueId != null);
1425 private RestResponse changeResourceStateToCertified(ResourceReqDetails resourceDetails) throws Exception {
1426 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
1427 LifeCycleStatesEnum.CHECKIN);
1428 ResourceRestUtils.checkSuccess(restResponse);
1429 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
1430 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1431 if (restResponse.getErrorCode() == 200) {
1432 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails,
1433 LifeCycleStatesEnum.STARTCERTIFICATION);
1435 return restResponse;
1436 if (restResponse.getErrorCode() == 200) {
1437 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails,
1438 LifeCycleStatesEnum.CERTIFY);
1439 if (restResponse.getErrorCode() == 200) {
1440 String newVersion = ResponseParser.getVersionFromResponse(restResponse);
1441 resourceDetails.setVersion(newVersion);
1442 resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1443 resourceDetails.setLastUpdaterUserId(sdncTesterDetails.getUserId());
1444 resourceDetails.setLastUpdaterFullName(sdncTesterDetails.getFullName());
1445 String uniqueIdFromRresponse = ResponseParser.getValueFromJsonResponse(restResponse.getResponse(),
1447 resourceDetails.setUniqueId(uniqueIdFromRresponse);
1450 return restResponse;
1453 private void certifyVf(ResourceReqDetails resource, ResourceReqDetails computeResource,
1454 ResourceReqDetails cpResource) throws Exception {
1455 RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, cpResource,
1456 sdncDesignerDetails);
1457 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1458 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1460 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, computeResource,
1461 sdncDesignerDetails);
1462 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1463 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1465 RestResponse response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails,
1466 sdncDesignerDetails, resource.getUniqueId());
1467 ResourceRestUtils.checkSuccess(response);
1469 String capOwnerId = toCompInstId;
1470 User user = sdncDesignerDetails;
1471 ComponentTypeEnum containerCompType = ComponentTypeEnum.RESOURCE;
1473 fulfillCpRequirement(resource, fromCompInstId, toCompInstId, capOwnerId, user, containerCompType);
1475 RestResponse changeResourceStateToCertified = changeResourceStateToCertified(resource);
1476 ResourceRestUtils.checkSuccess(changeResourceStateToCertified);