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.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertNotNull;
26 import java.io.IOException;
27 import java.util.ArrayList;
28 import java.util.Arrays;
29 import java.util.Iterator;
30 import java.util.List;
32 import org.junit.Rule;
33 import org.junit.rules.TestName;
34 import org.openecomp.sdc.be.dao.api.ActionStatus;
35 import org.openecomp.sdc.be.model.LifecycleStateEnum;
36 import org.openecomp.sdc.be.model.Product;
37 import org.openecomp.sdc.be.model.Resource;
38 import org.openecomp.sdc.be.model.User;
39 import org.openecomp.sdc.be.model.category.CategoryDefinition;
40 import org.openecomp.sdc.ci.tests.api.Urls;
41 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
42 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
43 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
44 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
45 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
46 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedProductAudit;
47 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
49 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
50 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
51 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
52 import org.openecomp.sdc.ci.tests.utils.rest.CatalogRestUtils;
53 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
54 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
55 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
56 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
57 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
58 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
59 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
60 import org.openecomp.sdc.ci.tests.utils.validation.ProductValidationUtils;
61 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
62 import org.openecomp.sdc.common.api.Constants;
63 import org.slf4j.Logger;
64 import org.slf4j.LoggerFactory;
65 import org.testng.annotations.Test;
67 import com.google.gson.JsonArray;
68 import com.google.gson.JsonElement;
69 import com.google.gson.JsonObject;
70 import com.google.gson.JsonParser;
72 public class ProductCrudTest extends ProductBaseTest {
73 private static Logger log = LoggerFactory.getLogger(ProductCrudTest.class.getName());
75 public static TestName name = new TestName();
77 public static String INITIAL_PRODUCT_VERSION = "0.1";
78 public static String CREATE_AUDIT_ACTION = "Create";
79 public static String UPDATE_AUDIT_ACTION = "Update";
80 public static String COMPONENT_TYPE = "Product";
82 private ProductReqDetails productReqDetails;
83 private RestResponse createProduct;
84 private Product product;
86 public ProductCrudTest() {
87 super(name, ProductCrudTest.class.getName());
90 @Test // (enabled=false)
91 public void createAndGetAll() throws Exception {
92 createProductAndGet(UserRoleEnum.DESIGNER);
95 private void createProductAndGet(UserRoleEnum user) throws Exception, IOException {
96 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
97 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
98 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
99 createProduct.getErrorCode().intValue());
101 RestResponse catalog = CatalogRestUtils.getCatalog(user.getUserId());
102 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_SUCCESS,
103 catalog.getErrorCode().intValue());
106 JsonElement jElement = new JsonParser().parse(catalog.getResponse());
107 JsonObject jObject = jElement.getAsJsonObject();
108 JsonArray products = (JsonArray) jObject.get("products");
109 assertEquals("Check product array size", 1, products.size());
110 Iterator<JsonElement> iter = products.iterator();
111 while (iter.hasNext()) {
112 JsonElement next = iter.next();
113 Product product = ResponseParser.parseToObjectUsingMapper(next.toString(), Product.class);
114 assertNotNull(product);
115 assertEquals("Check product name", productReqDetails.getName(), product.getName());
116 // Map<String, String> allVersions = product.getAllVersions();
117 // assertEquals("Check product name", 1, allVersions.size());
120 } catch (Exception e) {
121 log.debug("exception", e);
126 public void getAllNoProcduts() throws Exception {
128 RestResponse catalog = CatalogRestUtils.getCatalog();
129 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_SUCCESS,
130 catalog.getErrorCode().intValue());
133 JsonElement jElement = new JsonParser().parse(catalog.getResponse());
134 JsonObject jObject = jElement.getAsJsonObject();
135 JsonArray products = (JsonArray) jObject.get("products");
136 assertEquals("Check product array size", 0, products.size());
137 } catch (Exception e) {
138 log.debug("exception", e);
144 public void getAllNoAttHeader() throws Exception {
145 String url = String.format(Urls.GET_CATALOG_DATA, config.getCatalogBeHost(), config.getCatalogBePort());
147 List<String> headersToRemove = new ArrayList<String>();
148 headersToRemove.add(HttpHeaderEnum.USER_ID.getValue());
150 RestResponse catalog = CatalogRestUtils.sendGetAndRemoveHeaders(url, null, headersToRemove);
151 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
152 catalog.getErrorCode().intValue());
154 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
155 catalog.getResponse());
159 public void getAllWrongUser() throws Exception {
160 RestResponse catalog = CatalogRestUtils.getCatalog("kj8976");
161 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
162 catalog.getErrorCode().intValue());
164 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
165 catalog.getResponse());
168 @Test // (enabled=false)
169 public void getAllWithProductStrategist_User() throws Exception {
170 createProductAndGet(UserRoleEnum.PRODUCT_STRATEGIST1);
173 @Test // (enabled=false)
174 public void getAllWithProductManager_User() throws Exception {
175 createProductAndGet(UserRoleEnum.PRODUCT_MANAGER1);
178 @Test // (enabled=false)
179 public void createProductNoCategories() throws Exception {
180 createProductWithCategories(null);
183 @Test // (enabled=false)
184 public void createProductOneGrouping() throws Exception {
185 // Category1->[Subcategory1->[Grouping1]]
186 createProductWithCategories(defaultCategories);
189 @Test // (enabled=false)
190 public void createProductTwoGroupingsSameSubCategory() throws Exception {
191 // Category1->Subcategory1->[Grouping1, Grouping11]
192 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
193 createProductWithCategories(addSecondGroupingToDefaultCategory);
196 @Test // (enabled=false)
197 public void createProductTwoSubsDifferentGroupings() throws Exception {
198 // Category1->[Subcategory1->[Grouping1,
199 // Grouping11],Subcategory2->[Grouping12]]
200 List<CategoryDefinition> addSubcategoryAndGroupingToDefaultCategory = addSubcategoryAndGroupingToDefaultCategory();
201 createProductWithCategories(addSubcategoryAndGroupingToDefaultCategory);
204 @Test // (enabled=false)
205 public void createManyGroupingsDiffCategories() throws Exception {
206 // [Category1->[Subcategory1->[Grouping1,
207 // Grouping11],Subcategory2->[Grouping12]],
208 // Category2->[Subcategory1->[Grouping1],Subcategory2->[Grouping1]],
209 // Category3->[Subcategory1->[Grouping11],Subcategory2->[Grouping11,
211 List<CategoryDefinition> addSubcategoryAndGroupingToDefaultCategory = addManyGroupingsDiffCategories();
212 createProductWithCategories(addSubcategoryAndGroupingToDefaultCategory);
215 @Test // (enabled=false)
216 public void createProductEmptyUserId() throws Exception {
217 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
218 User emptyUser = new User();
219 emptyUser.setUserId("");
220 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, emptyUser);
221 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
222 createProduct.getErrorCode().intValue());
223 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
225 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
226 expectedProduct, CREATE_AUDIT_ACTION, emptyUser, ActionStatus.MISSING_INFORMATION,
227 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
228 constructFieldsForAuditValidation.setCURR_STATE("");
229 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
232 @Test // (enabled=false)
233 public void createProductNonExistingUserId() throws Exception {
234 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
235 User notExistingUser = new User();
236 notExistingUser.setUserId("jj6444");
237 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, notExistingUser);
238 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
239 createProduct.getErrorCode().intValue());
240 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
242 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
243 expectedProduct, CREATE_AUDIT_ACTION, notExistingUser, ActionStatus.RESTRICTED_OPERATION,
244 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
245 constructFieldsForAuditValidation.setCURR_STATE("");
246 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
249 @Test // (enabled=false)
250 public void createProductInvalidJson() throws Exception {
251 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
252 RestResponse createProduct = ProductRestUtils.createProduct_Invalid_Json(productManager1.getUserId());
253 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
254 createProduct.getErrorCode().intValue());
255 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
257 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
258 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_CONTENT,
259 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
260 constructFieldsForAuditValidation.setRESOURCE_NAME("");
261 constructFieldsForAuditValidation.setCURR_STATE("");
262 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
265 @Test // (enabled=false)
266 public void createProductAdminRoleNotAllowed() throws Exception {
267 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
268 User wrongRole = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
269 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, wrongRole);
270 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
271 createProduct.getErrorCode().intValue());
272 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
274 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
275 expectedProduct, CREATE_AUDIT_ACTION, wrongRole, ActionStatus.RESTRICTED_OPERATION,
276 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
277 constructFieldsForAuditValidation.setCURR_STATE("");
278 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
281 @Test // (enabled=false)
282 public void createProductProductStrategistRoleNotAllowed() throws Exception {
283 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
284 User wrongRole = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST3);
285 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, wrongRole);
286 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
287 createProduct.getErrorCode().intValue());
288 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
290 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
291 expectedProduct, CREATE_AUDIT_ACTION, wrongRole, ActionStatus.RESTRICTED_OPERATION,
292 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
293 constructFieldsForAuditValidation.setCURR_VERSION("");
294 constructFieldsForAuditValidation.setCURR_STATE("");
295 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
298 @Test // (enabled=false)
299 public void getProductSuccessFlow() throws Exception {
300 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
301 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
302 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
303 createProduct.getErrorCode().intValue());
305 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
306 productManager1.getUserId());
307 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
308 getProductRes.getErrorCode().intValue());
310 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
311 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
312 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
313 ComponentOperationEnum.GET_COMPONENT);
316 @Test // (enabled=false)
317 public void getNonExistedProduct() throws Exception {
319 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
320 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
321 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
322 createProduct.getErrorCode().intValue());
324 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
325 productManager1.getUserId());
326 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
327 getProductRes.getErrorCode().intValue());
329 Product product = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
330 assertEquals("Assert on product icon", productReqDetails.getName(), product.getName());
332 RestResponse deleteProductRes = ProductRestUtils.deleteProduct(productReqDetails.getUniqueId(),
333 productManager1.getUserId());
334 assertEquals("Check response code for deletign Product", BaseRestUtils.STATUS_CODE_SUCCESS,
335 deleteProductRes.getErrorCode().intValue());
337 RestResponse getProductAfterDeleteRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
338 productManager1.getUserId());
339 assertEquals("Check response code after getting deleted Product", BaseRestUtils.STATUS_CODE_NOT_FOUND,
340 getProductAfterDeleteRes.getErrorCode().intValue());
343 @Test // (enabled=false)
344 public void getProductMissingHeader() throws Exception {
346 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
347 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
348 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
349 createProduct.getErrorCode().intValue());
351 productManager1.setUserId(null);
352 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
353 productManager1.getUserId());
354 assertEquals("Check response code after getting created Producuct with userId extracted from header",
355 BaseRestUtils.STATUS_CODE_MISSING_INFORMATION, getProductRes.getErrorCode().intValue());
359 @Test // (enabled=false)
360 public void getProductNonExistingUser() throws Exception {
361 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
362 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
363 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
364 createProduct.getErrorCode().intValue());
366 productManager1.setUserId("bt1111");
367 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
368 productManager1.getUserId());
369 assertEquals("Check response code after getting created Producuct with non exsisting user",
370 BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION, getProductRes.getErrorCode().intValue());
373 @Test // (enabled=false)
374 public void createProductAndGetProductWithDifferentUser() throws Exception {
375 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
376 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
377 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
378 createProduct.getErrorCode().intValue());
379 User sdncProductStrategistUserAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
380 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
381 sdncProductStrategistUserAdminDetails.getUserId());
382 assertEquals("Check response code after getting created Product different user role",
383 BaseRestUtils.STATUS_CODE_SUCCESS, getProductRes.getErrorCode().intValue());
386 // US594753 - Update Product metadata
388 // If user update "product name" we need to remove the old product name from
389 // "Tags" and add the new product name instead - will handled in mew US
390 @Test(enabled = false)
391 public void updateProductAllFieldsByPM() throws Exception {
392 createProducrByPSAndCheckIn();
393 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
394 LifeCycleStatesEnum.CHECKOUT);
395 ProductRestUtils.checkSuccess(changeProductLifeCycle);
397 productReqDetails.setUniqueId(product.getUniqueId());
398 productReqDetails.setUUID(product.getUUID());
399 productReqDetails.setName("NewProductName");
400 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
401 productReqDetails.setFullName("New Full name");
402 productReqDetails.setActive("false");
403 productReqDetails.setContacts(
404 Arrays.asList(productManager2.getUserId().toLowerCase(), productManager1.getUserId().toLowerCase()));
405 productReqDetails.setDescription("New Product Description");
406 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbfv");
407 productReqDetails.setProjectCode("98765");
408 productReqDetails.setCategories(addSecondGroupingToDefaultCategory);
409 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
410 ProductRestUtils.checkSuccess(updateProduct);
411 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
413 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
414 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
415 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
416 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
417 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
418 expectedProduct.setUUID(product.getUUID());
419 expectedProduct.setInvariantUUID(product.getInvariantUUID());
420 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
421 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
422 ComponentOperationEnum.UPDATE_COMPONENT);
425 @Test // (enabled=false)
426 public void updateProductByPS() throws Exception {
427 createProducrByPSAndCheckIn();
428 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
429 LifeCycleStatesEnum.CHECKOUT);
430 ProductRestUtils.checkSuccess(changeProductLifeCycle);
431 productReqDetails.setUniqueId(product.getUniqueId());
432 productReqDetails.setUUID(product.getUUID());
433 productReqDetails.setDescription("New discription");
434 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productStrategistUser1);
435 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
436 updateProduct.getErrorCode().intValue());
437 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
438 updateProduct.getResponse());
441 @Test // (enabled=false)
442 public void updateProductByAdmin() throws Exception {
443 createProducrByPSAndCheckIn();
444 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
445 LifeCycleStatesEnum.CHECKOUT);
446 ProductRestUtils.checkSuccess(changeProductLifeCycle);
447 productReqDetails.setUniqueId(product.getUniqueId());
448 productReqDetails.setUUID(product.getUUID());
449 productReqDetails.setDescription("New discription");
450 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, designerUser);
451 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
452 updateProduct.getErrorCode().intValue());
453 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
454 updateProduct.getResponse());
457 @Test // (enabled=false)
458 public void updateProductByNonPmUser() throws Exception {
459 createProducrByPSAndCheckIn();
460 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
461 LifeCycleStatesEnum.CHECKOUT);
462 ProductRestUtils.checkSuccess(changeProductLifeCycle);
463 productReqDetails.setUniqueId(product.getUniqueId());
464 productReqDetails.setUUID(product.getUUID());
465 // Update product name
466 productReqDetails.setDescription("New discription");
467 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, designerUser);
468 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
469 updateProduct.getErrorCode().intValue());
470 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
471 updateProduct.getResponse());
474 @Test // (enabled=false)
475 public void updateProductByNonAsdcUser() throws Exception {
476 createProducrByPSAndCheckIn();
477 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
478 LifeCycleStatesEnum.CHECKOUT);
479 ProductRestUtils.checkSuccess(changeProductLifeCycle);
480 productReqDetails.setUniqueId(product.getUniqueId());
481 productReqDetails.setUUID(product.getUUID());
482 // Update product name
483 productReqDetails.setDescription("New discription");
484 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
485 nonAsdcUser.setUserId("bt789k");
486 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, nonAsdcUser);
487 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
488 updateProduct.getErrorCode().intValue());
489 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
490 updateProduct.getResponse());
493 @Test // (enabled=false)
494 public void updateProductUserIdIsEmpty() throws Exception {
495 createProducrByPSAndCheckIn();
496 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
497 LifeCycleStatesEnum.CHECKOUT);
498 ProductRestUtils.checkSuccess(changeProductLifeCycle);
499 productReqDetails.setUniqueId(product.getUniqueId());
500 productReqDetails.setUUID(product.getUUID());
501 // Update product name
502 productReqDetails.setDescription("New discription");
503 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
504 nonAsdcUser.setUserId("");
505 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, nonAsdcUser);
506 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
507 updateProduct.getErrorCode().intValue());
508 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
509 updateProduct.getResponse());
512 @Test // (enabled=false)
513 public void updateProductByNonProductOwner() throws Exception {
514 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
515 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
516 ProductRestUtils.checkCreateResponse(createProduct);
517 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
518 productReqDetails.setUniqueId(product.getUniqueId());
519 productReqDetails.setUUID(product.getUUID());
520 productReqDetails.setDescription("New discription");
521 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
522 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
523 updateProduct.getErrorCode().intValue());
524 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
525 updateProduct.getResponse());
526 // Get Product and verify that metadata didn't change
527 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
528 productManager1.getUserId());
529 ProductRestUtils.checkSuccess(getProduct);
530 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
531 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
532 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
533 ComponentOperationEnum.GET_COMPONENT);
536 @Test // (enabled=false)
537 public void updateProductNotInCheckoutState() throws Exception {
538 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
539 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
540 ProductRestUtils.checkCreateResponse(createProduct);
541 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
542 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
543 LifeCycleStatesEnum.CHECKIN);
544 ProductRestUtils.checkSuccess(changeProductLifeCycle);
545 productReqDetails.setUniqueId(product.getUniqueId());
546 productReqDetails.setUUID(product.getUUID());
547 // Update product name
548 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
549 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
550 updateProduct.getErrorCode().intValue());
551 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
552 updateProduct.getResponse());
553 // Get Product and verify that metadata didn't change
554 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
555 productManager1.getUserId());
556 ProductRestUtils.checkSuccess(getProduct);
557 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
558 expectedProduct.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
559 String valueFromJsonResponse = ResponseParser.getValueFromJsonResponse(changeProductLifeCycle.getResponse(),
561 expectedProduct.setLastUpdateDate(Long.parseLong(valueFromJsonResponse));
562 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
563 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
564 ComponentOperationEnum.UPDATE_COMPONENT);
567 @Test // (enabled=false)
568 public void updateProductNameIsEmpty() throws Exception {
569 createProducrByPSAndCheckIn();
570 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
571 LifeCycleStatesEnum.CHECKOUT);
572 ProductRestUtils.checkSuccess(changeProductLifeCycle);
573 productReqDetails.setUniqueId(product.getUniqueId());
574 productReqDetails.setUUID(product.getUUID());
575 productReqDetails.setName("");
576 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
577 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
578 updateProduct.getErrorCode().intValue());
579 ArrayList<String> varibales = new ArrayList<String>();
580 varibales.add(COMPONENT_TYPE);
581 varibales.add("abbreviated");
582 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES.name(), varibales,
583 updateProduct.getResponse());
584 // Get Product and verify that metadata didn't change
585 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
586 productManager1.getUserId());
587 ProductRestUtils.checkSuccess(getProduct);
588 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
589 expectedProduct.setUniqueId(product.getUniqueId());
590 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
591 expectedProduct.setVersion(product.getVersion());
592 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
593 ComponentOperationEnum.UPDATE_COMPONENT);
596 @Test // (enabled=false)
597 public void updateProductNameIsNull() throws Exception {
598 createProducrByPSAndCheckIn();
599 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager2,
600 LifeCycleStatesEnum.CHECKOUT);
601 ProductRestUtils.checkSuccess(changeProductLifeCycle);
602 // List<String> tags = productReqDetails.getTags();
603 // tags.removeAll(tags);
604 productReqDetails.setTags(new ArrayList<>());
605 productReqDetails.setUniqueId(product.getUniqueId());
606 productReqDetails.setUUID(product.getUUID());
607 productReqDetails.setName(null); // no update will be performed
608 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
609 ProductRestUtils.checkSuccess(updateProduct);
610 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
611 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager2);
612 expectedProduct.setUUID(product.getUUID());
613 expectedProduct.setInvariantUUID(product.getInvariantUUID());
614 expectedProduct.setNormalizedName(product.getName().toLowerCase());
615 expectedProduct.setName(product.getName());
616 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
617 ComponentOperationEnum.UPDATE_COMPONENT);
620 @Test // (enabled=false)
621 public void updateProductNameLessThanMinLength() throws Exception {
622 createProducrByPSAndCheckIn();
623 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
624 LifeCycleStatesEnum.CHECKOUT);
625 ProductRestUtils.checkSuccess(changeProductLifeCycle);
626 productReqDetails.setUniqueId(product.getUniqueId());
627 productReqDetails.setUUID(product.getUUID());
628 productReqDetails.setName("ABC"); // no update will be performed
629 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
630 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
631 updateProduct.getErrorCode().intValue());
632 ArrayList<String> varibales = new ArrayList<String>();
633 varibales.add(COMPONENT_TYPE);
634 varibales.add("abbreviated");
635 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
636 varibales, updateProduct.getResponse());
637 // Get Product and verify that metadata didn't change
638 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
639 productManager1.getUserId());
640 ProductRestUtils.checkSuccess(getProduct);
641 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
642 expectedProduct.setUniqueId(product.getUniqueId());
643 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
644 expectedProduct.setVersion(product.getVersion());
645 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
646 ComponentOperationEnum.UPDATE_COMPONENT);
649 // If user update "product name" we need to remove the old product name from
650 // "Tags" and add the new product name instead - will handled in mew US
651 @Test(enabled = false)
652 public void updateProductNameHasMinLength() throws Exception {
653 createProducrByPSAndCheckIn();
654 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager2,
655 LifeCycleStatesEnum.CHECKOUT);
656 ProductRestUtils.checkSuccess(changeProductLifeCycle);
657 productReqDetails.setUniqueId(product.getUniqueId());
658 productReqDetails.setUUID(product.getUUID());
659 productReqDetails.setName("NewP");
660 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
661 ProductRestUtils.checkSuccess(updateProduct);
662 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
663 productReqDetails.setLastUpdaterUserId(productManager2.getUserId());
664 productReqDetails.setLastUpdaterFullName(productManager2.getFullName());
665 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
666 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager2);
667 expectedProduct.setUUID(product.getUUID());
668 expectedProduct.setInvariantUUID(product.getInvariantUUID());
669 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
670 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
671 ComponentOperationEnum.UPDATE_COMPONENT);
674 // If user update "product name" we need to remove the old product name from
675 // "Tags" and add the new product name instead - will handled in mew US
676 // DE193857 - Normalized Name is not removing special characters
677 @Test(enabled = false)
678 public void updateProductNameMaxLength() throws Exception {
679 createProducrByPSAndCheckIn();
680 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
681 LifeCycleStatesEnum.CHECKOUT);
682 ProductRestUtils.checkSuccess(changeProductLifeCycle);
683 // Update product name
684 productReqDetails.setUniqueId(product.getUniqueId());
685 productReqDetails.setUUID(product.getUUID());
686 productReqDetails.setName("Ac_2B3U4k mSKnob-u.j-uGgP");
687 String newNormalizedName = "ac2b3u4kmsknobujuggp";
688 String newName = "Ac_2B3U4k MSKnob-u.j-uGgP";
689 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
690 ProductRestUtils.checkSuccess(updateProduct);
691 productReqDetails.setTags(Arrays.asList(newName));
692 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
693 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
694 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
695 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
696 expectedProduct.setUUID(product.getUUID());
697 expectedProduct.setInvariantUUID(product.getInvariantUUID());
698 expectedProduct.setNormalizedName(newNormalizedName);
699 expectedProduct.setName(newName);
700 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
701 ComponentOperationEnum.UPDATE_COMPONENT);
704 @Test // (enabled=false)
705 public void updateProductNameExceedMaxLength() throws Exception {
706 createProducrByPSAndCheckIn();
707 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
708 LifeCycleStatesEnum.CHECKOUT);
709 ProductRestUtils.checkSuccess(changeProductLifeCycle);
710 productReqDetails.setUniqueId(product.getUniqueId());
711 productReqDetails.setUUID(product.getUUID());
712 productReqDetails.setName("Ac_2B3U4k mSKnob-u.j-uGgPx");
713 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
714 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
715 updateProduct.getErrorCode().intValue());
716 ArrayList<String> varibales = new ArrayList<String>();
717 varibales.add(COMPONENT_TYPE);
718 varibales.add("abbreviated");
719 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
720 varibales, updateProduct.getResponse());
721 // Get Product and verify that metadata didn't change
722 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
723 productManager1.getUserId());
724 ProductRestUtils.checkSuccess(getProduct);
725 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
726 expectedProduct.setUniqueId(product.getUniqueId());
727 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
728 expectedProduct.setVersion(product.getVersion());
729 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
730 ComponentOperationEnum.UPDATE_COMPONENT);
733 @Test // (enabled=false)
734 public void updateProductNameAlreadyExist() throws Exception {
735 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
736 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager2);
737 ProductRestUtils.checkCreateResponse(createProduct);
738 Product product1 = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
739 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product1, productManager2,
740 LifeCycleStatesEnum.CHECKIN);
741 ProductRestUtils.checkSuccess(changeProductLifeCycle);
742 productReqDetails.setName("Product2000");
743 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
744 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager2);
745 ProductRestUtils.checkCreateResponse(createProduct);
746 Product product2 = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
747 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product2, productManager2,
748 LifeCycleStatesEnum.CHECKIN);
749 ProductRestUtils.checkSuccess(changeProductLifeCycle);
750 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product2, productManager2,
751 LifeCycleStatesEnum.CHECKOUT);
752 ProductRestUtils.checkSuccess(changeProductLifeCycle);
753 productReqDetails.setUniqueId(product2.getUniqueId());
754 productReqDetails.setUUID(product2.getUUID());
755 productReqDetails.setName(product1.getName());
756 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
757 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_ALREADY_EXISTS,
758 updateProduct.getErrorCode().intValue());
759 ArrayList<String> varibales = new ArrayList<String>();
760 varibales.add(COMPONENT_TYPE);
761 varibales.add(product1.getName());
762 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name(), varibales,
763 updateProduct.getResponse());
764 // Get Product and verify that metadata didn't change
765 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
766 productManager2.getUserId());
767 ProductRestUtils.checkSuccess(getProduct);
768 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
769 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
770 expectedProduct.setUniqueId(product2.getUniqueId());
771 expectedProduct.setVersion(product2.getVersion());
772 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
773 ComponentOperationEnum.UPDATE_COMPONENT);
776 // DE193857 - Normalized Name is not removing special characters
777 // If user update "product name" we need to remove the old product name from
778 // "Tags" and add the new product name instead - will handled in mew US
779 @Test(enabled = false)
780 public void updateProductNameAllowedCharacters() throws Exception {
781 createProducrByPSAndCheckIn();
782 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
783 LifeCycleStatesEnum.CHECKOUT);
784 ProductRestUtils.checkSuccess(changeProductLifeCycle);
785 // Update product name
786 productReqDetails.setUniqueId(product.getUniqueId());
787 productReqDetails.setUUID(product.getUUID());
788 productReqDetails.setName("A_BU4k m&K=o#b-u.j-uG'g+P"); // Allowed
806 String newNormalizedName = "abu4km&kobujuggp";
807 String newName = "A_BU4k M&K=o#b-u.j-uG'g+P";
808 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
809 ProductRestUtils.checkSuccess(updateProduct);
810 productReqDetails.setTags(Arrays.asList(newName));
811 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
812 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
813 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
814 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
815 expectedProduct.setUUID(product.getUUID());
816 expectedProduct.setInvariantUUID(product.getInvariantUUID());
817 expectedProduct.setNormalizedName(newNormalizedName);
818 expectedProduct.setName(newName);
819 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
820 ComponentOperationEnum.UPDATE_COMPONENT);
823 // If user update "product name" we need to remove the old product name from
824 // "Tags" and add the new product name instead - will handled in mew US
825 @Test(enabled = false)
826 public void updateProductNameRemoveSpaceFromBeginning() throws Exception {
827 createProducrByPSAndCheckIn();
828 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
829 LifeCycleStatesEnum.CHECKOUT);
830 ProductRestUtils.checkSuccess(changeProductLifeCycle);
831 productReqDetails.setUniqueId(product.getUniqueId());
832 productReqDetails.setUUID(product.getUUID());
833 productReqDetails.setName(" asdfg");
834 String newNormalizedName = "asdfg";
835 String newName = "Asdfg";
836 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
837 ProductRestUtils.checkSuccess(updateProduct);
838 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
839 productReqDetails.setTags(Arrays.asList(newName));
840 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
841 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
842 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
843 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
844 expectedProduct.setUUID(product.getUUID());
845 expectedProduct.setInvariantUUID(product.getInvariantUUID());
846 expectedProduct.setNormalizedName(newNormalizedName);
847 expectedProduct.setName(newName);
848 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
849 ComponentOperationEnum.UPDATE_COMPONENT);
852 // If user update "product name" we need to remove the old product name from
853 // "Tags" and add the new product name instead - will handled in mew US
854 @Test(enabled = false)
855 public void updateProductNameRemoveSpaceFromEnd() throws Exception {
856 createProducrByPSAndCheckIn();
857 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
858 LifeCycleStatesEnum.CHECKOUT);
859 ProductRestUtils.checkSuccess(changeProductLifeCycle);
860 productReqDetails.setUniqueId(product.getUniqueId());
861 productReqDetails.setUUID(product.getUUID());
862 productReqDetails.setName("asdfg fc ");
863 String newNormalizedName = "asdfgfc";
864 String newName = "Asdfg Fc";
865 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
866 ProductRestUtils.checkSuccess(updateProduct);
867 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
868 productReqDetails.setTags(Arrays.asList(newName));
869 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
870 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
871 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
872 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
873 expectedProduct.setUUID(product.getUUID());
874 expectedProduct.setInvariantUUID(product.getInvariantUUID());
875 expectedProduct.setNormalizedName(newNormalizedName);
876 expectedProduct.setName(newName);
877 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
878 ComponentOperationEnum.UPDATE_COMPONENT);
881 //// DE193857 - Normalized Name is not removing special characters
882 // If user update "product name" we need to remove the old product name from
883 //// "Tags" and add the new product name instead - will handled in mew US
884 @Test(enabled = false)
885 public void updateProductNameRemoveExtraNonAlphanumericChars() throws Exception {
886 createProducrByPSAndCheckIn();
887 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
888 LifeCycleStatesEnum.CHECKOUT);
889 ProductRestUtils.checkSuccess(changeProductLifeCycle);
890 productReqDetails.setUniqueId(product.getUniqueId());
891 productReqDetails.setUUID(product.getUUID());
892 productReqDetails.setName("A__k &&==##---u..hG'''+++");
893 String newNormalizedName = "akhg";
894 String newName = "A_k &=#-u.hG'+";
895 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
896 ProductRestUtils.checkSuccess(updateProduct);
897 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
898 productReqDetails.setTags(Arrays.asList(newName));
899 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
900 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
901 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
902 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
903 expectedProduct.setUUID(product.getUUID());
904 expectedProduct.setInvariantUUID(product.getInvariantUUID());
905 expectedProduct.setNormalizedName(newNormalizedName);
906 expectedProduct.setName(newName);
907 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
908 ComponentOperationEnum.UPDATE_COMPONENT);
911 // If user update "product name" we need to remove the old product name from
912 // "Tags" and add the new product name instead - will handled in mew US
913 @Test(enabled = false)
914 public void updateProductNameValidationStartWithNumber() throws Exception {
915 createProducrByPSAndCheckIn();
916 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
917 LifeCycleStatesEnum.CHECKOUT);
918 ProductRestUtils.checkSuccess(changeProductLifeCycle);
919 productReqDetails.setUniqueId(product.getUniqueId());
920 productReqDetails.setUUID(product.getUUID());
921 productReqDetails.setName("1000Ab");
922 String newNormalizedName = productReqDetails.getName().toLowerCase();
923 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
924 ProductRestUtils.checkSuccess(updateProduct);
925 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
926 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
928 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
929 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
930 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
931 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
932 expectedProduct.setUUID(product.getUUID());
933 expectedProduct.setInvariantUUID(product.getInvariantUUID());
934 expectedProduct.setNormalizedName(newNormalizedName);
935 expectedProduct.setName(productReqDetails.getName());
936 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
937 ComponentOperationEnum.UPDATE_COMPONENT);
940 @Test // (enabled=false)
941 public void updateProductNameValidationStartWithNonAlphaNumeric() throws Exception {
942 createProducrByPSAndCheckIn();
943 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
944 LifeCycleStatesEnum.CHECKOUT);
945 ProductRestUtils.checkSuccess(changeProductLifeCycle);
946 productReqDetails.setUniqueId(product.getUniqueId());
947 productReqDetails.setUUID(product.getUUID());
948 productReqDetails.setName("_1000Ab");
949 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
950 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
951 updateProduct.getErrorCode().intValue());
952 ArrayList<String> varibales = new ArrayList<String>();
953 varibales.add(COMPONENT_TYPE);
954 varibales.add("abbreviated");
955 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT.name(),
956 varibales, updateProduct.getResponse());
957 // Get Product and verify that metadata didn't change
958 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
959 productManager1.getUserId());
960 ProductRestUtils.checkSuccess(getProduct);
961 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
962 expectedProduct.setUniqueId(product.getUniqueId());
963 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
964 expectedProduct.setVersion(product.getVersion());
965 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
966 ComponentOperationEnum.UPDATE_COMPONENT);
969 @Test // (enabled=false)
970 public void updateProductFullNameIsEmpty() throws Exception {
971 createProducrByPSAndCheckIn();
972 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
973 LifeCycleStatesEnum.CHECKOUT);
974 ProductRestUtils.checkSuccess(changeProductLifeCycle);
975 productReqDetails.setUniqueId(product.getUniqueId());
976 productReqDetails.setUUID(product.getUUID());
977 productReqDetails.setFullName("");
978 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
979 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
980 updateProduct.getErrorCode().intValue());
981 ArrayList<String> varibales = new ArrayList<String>();
982 varibales.add(COMPONENT_TYPE);
983 varibales.add("full");
984 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES.name(), varibales,
985 updateProduct.getResponse());
986 // Get Product and verify that metadata didn't change
987 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
988 productManager1.getUserId());
989 ProductRestUtils.checkSuccess(getProduct);
990 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
991 expectedProduct.setUniqueId(product.getUniqueId());
992 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
993 expectedProduct.setVersion(product.getVersion());
994 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
995 ComponentOperationEnum.UPDATE_COMPONENT);
998 @Test // (enabled=false)
999 public void updateProductFullNameIsNull() throws Exception {
1000 createProducrByPSAndCheckIn();
1001 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1002 LifeCycleStatesEnum.CHECKOUT);
1003 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1004 productReqDetails.setUniqueId(product.getUniqueId());
1005 productReqDetails.setUUID(product.getUUID());
1006 productReqDetails.setFullName(null);
1007 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1008 ProductRestUtils.checkSuccess(updateProduct);
1009 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1010 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1011 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1012 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1013 expectedProduct.setUUID(product.getUUID());
1014 expectedProduct.setNormalizedName(product.getNormalizedName());
1015 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1016 expectedProduct.setFullName(product.getFullName());
1017 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1018 ComponentOperationEnum.UPDATE_COMPONENT);
1021 @Test // (enabled=false)
1022 public void updateProductFullNameHasMinLength() throws Exception {
1023 createProducrByPSAndCheckIn();
1024 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1025 LifeCycleStatesEnum.CHECKOUT);
1026 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1027 productReqDetails.setUniqueId(product.getUniqueId());
1028 productReqDetails.setUUID(product.getUUID());
1029 productReqDetails.setFullName("asdc");
1030 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1031 ProductRestUtils.checkSuccess(updateProduct);
1032 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1033 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1034 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1035 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1036 expectedProduct.setUUID(product.getUUID());
1037 expectedProduct.setNormalizedName(product.getNormalizedName());
1038 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1039 expectedProduct.setFullName(productReqDetails.getFullName());
1040 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1041 ComponentOperationEnum.UPDATE_COMPONENT);
1044 @Test // (enabled=false)
1045 public void updateProductFullNameHasMaxLength() throws Exception {
1046 createProducrByPSAndCheckIn();
1047 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1048 LifeCycleStatesEnum.CHECKOUT);
1049 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1050 productReqDetails.setUniqueId(product.getUniqueId());
1051 productReqDetails.setUUID(product.getUUID());
1052 productReqDetails.setFullName(
1053 "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk");
1054 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1055 ProductRestUtils.checkSuccess(updateProduct);
1056 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1057 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1058 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1059 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1060 expectedProduct.setUUID(product.getUUID());
1061 expectedProduct.setNormalizedName(product.getNormalizedName());
1062 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1063 expectedProduct.setFullName(productReqDetails.getFullName());
1064 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1065 ComponentOperationEnum.UPDATE_COMPONENT);
1068 @Test // (enabled=false)
1069 public void updateProductFullNamelessThanMinLength() throws Exception {
1070 createProducrByPSAndCheckIn();
1071 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1072 LifeCycleStatesEnum.CHECKOUT);
1073 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1074 productReqDetails.setUniqueId(product.getUniqueId());
1075 productReqDetails.setUUID(product.getUUID());
1076 productReqDetails.setFullName("123");
1077 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1078 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1079 updateProduct.getErrorCode().intValue());
1080 ArrayList<String> varibales = new ArrayList<String>();
1081 varibales.add(COMPONENT_TYPE);
1082 varibales.add("full");
1083 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
1084 varibales, updateProduct.getResponse());
1085 // Get Product and verify that metadata didn't change
1086 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1087 productManager1.getUserId());
1088 ProductRestUtils.checkSuccess(getProduct);
1089 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1090 expectedProduct.setUniqueId(product.getUniqueId());
1091 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1092 expectedProduct.setVersion(product.getVersion());
1093 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1094 ComponentOperationEnum.UPDATE_COMPONENT);
1097 @Test // (enabled=false)
1098 public void updateProductFullNameExceedMaxLength() throws Exception {
1099 createProducrByPSAndCheckIn();
1100 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1101 LifeCycleStatesEnum.CHECKOUT);
1102 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1103 productReqDetails.setUniqueId(product.getUniqueId());
1104 productReqDetails.setUUID(product.getUUID());
1105 productReqDetails.setFullName(
1106 "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjkx");
1107 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1108 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1109 updateProduct.getErrorCode().intValue());
1110 ArrayList<String> varibales = new ArrayList<String>();
1111 varibales.add(COMPONENT_TYPE);
1112 varibales.add("full");
1113 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
1114 varibales, updateProduct.getResponse());
1115 // Get Product and verify that metadata didn't change
1116 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1117 productManager1.getUserId());
1118 ProductRestUtils.checkSuccess(getProduct);
1119 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1120 expectedProduct.setUniqueId(product.getUniqueId());
1121 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1122 expectedProduct.setVersion(product.getVersion());
1123 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1124 ComponentOperationEnum.UPDATE_COMPONENT);
1129 public void updateProductFullNameWithSpecialCharacters() throws Exception {
1130 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
1131 '\\', ',', '$', '#', '@', '+' };
1132 String fullName = "avbng";
1133 createProducrByPSAndCheckIn();
1134 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1135 LifeCycleStatesEnum.CHECKOUT);
1136 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1137 productReqDetails.setUniqueId(product.getUniqueId());
1138 productReqDetails.setUUID(product.getUUID());
1139 for (int i = 0; i < invalidChars.length; i++) {
1140 productReqDetails.setFullName(fullName + invalidChars[i]);
1141 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1142 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
1143 updateProduct.getErrorCode().intValue());
1147 @Test // (enabled=false)
1148 public void updateProductFullNameValidCharactersCharacters01() throws Exception {
1149 createProducrByPSAndCheckIn();
1150 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1151 LifeCycleStatesEnum.CHECKOUT);
1152 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1153 productReqDetails.setUniqueId(product.getUniqueId());
1154 productReqDetails.setUUID(product.getUUID());
1155 productReqDetails.setFullName("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
1156 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1157 ProductRestUtils.checkSuccess(updateProduct);
1158 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1159 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1160 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1161 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1162 expectedProduct.setUUID(product.getUUID());
1163 expectedProduct.setNormalizedName(product.getNormalizedName());
1164 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1165 expectedProduct.setFullName("qwertyuiopasdfghjklzxcvbnm1234567890Bold<");
1166 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1167 ComponentOperationEnum.UPDATE_COMPONENT);
1170 @Test // (enabled=false)
1171 public void updateProductFullNameRemoveExtraSpaces() throws Exception {
1172 createProducrByPSAndCheckIn();
1173 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1174 LifeCycleStatesEnum.CHECKOUT);
1175 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1176 productReqDetails.setUniqueId(product.getUniqueId());
1177 productReqDetails.setUUID(product.getUUID());
1178 productReqDetails.setFullName("Abbaaa a1");
1179 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1180 ProductRestUtils.checkSuccess(updateProduct);
1181 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1182 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1183 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1184 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1185 expectedProduct.setUUID(product.getUUID());
1186 expectedProduct.setNormalizedName(product.getNormalizedName());
1187 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1188 expectedProduct.setFullName("Abbaaa a1");
1189 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1190 ComponentOperationEnum.UPDATE_COMPONENT);
1193 @Test // (enabled=false)
1194 public void updateProductDescriptionIsEmpty() throws Exception {
1195 createProducrByPSAndCheckIn();
1196 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1197 LifeCycleStatesEnum.CHECKOUT);
1198 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1199 productReqDetails.setUniqueId(product.getUniqueId());
1200 productReqDetails.setUUID(product.getUUID());
1201 productReqDetails.setDescription("");
1202 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1203 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1204 updateProduct.getErrorCode().intValue());
1205 ArrayList<String> varibales = new ArrayList<String>();
1206 varibales.add(COMPONENT_TYPE);
1207 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name(), varibales,
1208 updateProduct.getResponse());
1209 // Get Product and verify that metadata didn't change
1210 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1211 productManager1.getUserId());
1212 ProductRestUtils.checkSuccess(getProduct);
1213 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1214 expectedProduct.setUniqueId(product.getUniqueId());
1215 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1216 expectedProduct.setVersion(product.getVersion());
1217 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1218 ComponentOperationEnum.UPDATE_COMPONENT);
1221 @Test // (enabled=false)
1222 public void updateProductDescriptionIsNull() throws Exception {
1223 createProducrByPSAndCheckIn();
1224 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1225 LifeCycleStatesEnum.CHECKOUT);
1226 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1227 productReqDetails.setUniqueId(product.getUniqueId());
1228 productReqDetails.setUUID(product.getUUID());
1229 productReqDetails.setDescription(null);
1230 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1231 ProductRestUtils.checkSuccess(updateProduct);
1232 // Get Product and verify that metadata didn't change
1233 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1234 productManager1.getUserId());
1235 ProductRestUtils.checkSuccess(getProduct);
1236 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1237 expectedProduct.setUniqueId(product.getUniqueId());
1238 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1239 expectedProduct.setVersion(product.getVersion());
1240 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1241 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1242 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1243 ComponentOperationEnum.UPDATE_COMPONENT);
1246 @Test(enabled = false)
1247 public void updateProductDescriptionValidCharacters01() throws Exception {
1248 createProducrByPSAndCheckIn();
1249 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1250 LifeCycleStatesEnum.CHECKOUT);
1251 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1252 productReqDetails.setUniqueId(product.getUniqueId());
1253 productReqDetails.setUUID(product.getUUID());
1254 productReqDetails.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
1255 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1256 ProductRestUtils.checkSuccess(updateProduct);
1257 // Get Product and verify that metadata didn't change
1258 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1259 productManager1.getUserId());
1260 ProductRestUtils.checkSuccess(getProduct);
1261 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1262 expectedProduct.setUniqueId(product.getUniqueId());
1263 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1264 expectedProduct.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
1265 expectedProduct.setVersion(product.getVersion());
1266 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1267 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1268 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1269 ComponentOperationEnum.UPDATE_COMPONENT);
1272 @Test // (enabled=false)
1273 public void updateProductDescriptionValidCharacters02() throws Exception {
1274 createProducrByPSAndCheckIn();
1275 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1276 LifeCycleStatesEnum.CHECKOUT);
1277 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1278 productReqDetails.setUniqueId(product.getUniqueId());
1279 productReqDetails.setUUID(product.getUUID());
1280 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
1281 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1282 ProductRestUtils.checkSuccess(updateProduct);
1283 // Get Product and verify that metadata didn't change
1284 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1285 productManager1.getUserId());
1286 ProductRestUtils.checkSuccess(getProduct);
1287 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1288 expectedProduct.setUniqueId(product.getUniqueId());
1289 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1290 expectedProduct.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890Bold<");
1291 expectedProduct.setVersion(product.getVersion());
1292 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1293 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1294 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1295 ComponentOperationEnum.UPDATE_COMPONENT);
1298 @Test // (enabled=false)
1299 public void updateProductDescriptionInValidCharacters() throws Exception {
1300 createProducrByPSAndCheckIn();
1301 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1302 LifeCycleStatesEnum.CHECKOUT);
1303 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1304 productReqDetails.setUniqueId(product.getUniqueId());
1305 productReqDetails.setUUID(product.getUUID());
1306 productReqDetails.setDescription("מה");
1307 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1308 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1309 updateProduct.getErrorCode().intValue());
1310 ArrayList<String> varibales = new ArrayList<String>();
1311 varibales.add(COMPONENT_TYPE);
1312 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_DESCRIPTION.name(), varibales,
1313 updateProduct.getResponse());
1314 // Get Product and verify that metadata didn't change
1315 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1316 productManager1.getUserId());
1317 ProductRestUtils.checkSuccess(getProduct);
1318 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1319 expectedProduct.setUniqueId(product.getUniqueId());
1320 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1321 expectedProduct.setVersion(product.getVersion());
1322 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1323 ComponentOperationEnum.UPDATE_COMPONENT);
1326 @Test // (enabled=false)
1327 public void updateProductDescriptionRemoveSpacesFromBeginning() throws Exception {
1328 createProducrByPSAndCheckIn();
1329 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1330 LifeCycleStatesEnum.CHECKOUT);
1331 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1332 productReqDetails.setUniqueId(product.getUniqueId());
1333 productReqDetails.setUUID(product.getUUID());
1334 productReqDetails.setDescription(" abcd12345 g");
1335 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1336 ProductRestUtils.checkSuccess(updateProduct);
1337 // Get Product and verify that metadata didn't change
1338 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1339 productManager1.getUserId());
1340 ProductRestUtils.checkSuccess(getProduct);
1341 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1342 expectedProduct.setUniqueId(product.getUniqueId());
1343 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1344 expectedProduct.setDescription(" abcd12345 g");
1345 expectedProduct.setVersion(product.getVersion());
1346 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1347 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1348 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1349 ComponentOperationEnum.UPDATE_COMPONENT);
1352 @Test // (enabled=false)
1353 public void updateProductDescriptionRemoveSpacesFromTheEnd() throws Exception {
1354 createProducrByPSAndCheckIn();
1355 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1356 LifeCycleStatesEnum.CHECKOUT);
1357 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1358 productReqDetails.setUniqueId(product.getUniqueId());
1359 productReqDetails.setUUID(product.getUUID());
1360 productReqDetails.setDescription("abcd12345 gdf ");
1361 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1362 ProductRestUtils.checkSuccess(updateProduct);
1363 // Get Product and verify that metadata didn't change
1364 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1365 productManager1.getUserId());
1366 ProductRestUtils.checkSuccess(getProduct);
1367 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1368 expectedProduct.setUniqueId(product.getUniqueId());
1369 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1370 expectedProduct.setDescription("abcd12345 gdf ");
1371 expectedProduct.setVersion(product.getVersion());
1372 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1373 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1374 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1375 ComponentOperationEnum.UPDATE_COMPONENT);
1378 @Test // (enabled=false)
1379 public void updateProductDescriptionMaxLength() throws Exception {
1380 createProducrByPSAndCheckIn();
1381 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1382 LifeCycleStatesEnum.CHECKOUT);
1383 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1384 productReqDetails.setUniqueId(product.getUniqueId());
1385 productReqDetails.setUUID(product.getUUID());
1386 String description = "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfg";
1387 productReqDetails.setDescription(description);
1388 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1389 ProductRestUtils.checkSuccess(updateProduct);
1390 // Get Product and verify that metadata change
1391 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1392 productManager1.getUserId());
1393 ProductRestUtils.checkSuccess(getProduct);
1394 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1395 expectedProduct.setUniqueId(product.getUniqueId());
1396 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1397 expectedProduct.setDescription(description);
1398 expectedProduct.setVersion(product.getVersion());
1399 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1400 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1401 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1402 ComponentOperationEnum.UPDATE_COMPONENT);
1405 @Test // (enabled=false)
1406 public void updateProductDescriptionExceedMaxLength() throws Exception {
1407 createProducrByPSAndCheckIn();
1408 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1409 LifeCycleStatesEnum.CHECKOUT);
1410 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1411 productReqDetails.setUniqueId(product.getUniqueId());
1412 productReqDetails.setUUID(product.getUUID());
1413 String description = "01234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfg";
1414 productReqDetails.setDescription(description);
1415 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1416 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1417 updateProduct.getErrorCode().intValue());
1418 ArrayList<String> varibales = new ArrayList<String>();
1419 varibales.add(COMPONENT_TYPE);
1420 varibales.add("1024");
1421 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT.name(),
1422 varibales, updateProduct.getResponse());
1423 // Get Product and verify that metadata didn't change
1424 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1425 productManager1.getUserId());
1426 ProductRestUtils.checkSuccess(getProduct);
1427 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1428 expectedProduct.setUniqueId(product.getUniqueId());
1429 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1430 expectedProduct.setVersion(product.getVersion());
1431 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1432 ComponentOperationEnum.UPDATE_COMPONENT);
1435 @Test // (enabled=false)
1436 public void updateProductTagIsEmpty() throws Exception {
1437 createProducrByPSAndCheckIn();
1438 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1439 LifeCycleStatesEnum.CHECKOUT);
1440 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1441 productReqDetails.setUniqueId(product.getUniqueId());
1442 productReqDetails.setUUID(product.getUUID());
1443 productReqDetails.setTags(Arrays.asList(""));
1444 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1445 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1446 updateProduct.getErrorCode().intValue());
1447 ArrayList<String> varibales = new ArrayList<String>();
1448 varibales.add(COMPONENT_TYPE);
1449 varibales.add("tag");
1450 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FIELD_FORMAT.name(), varibales,
1451 updateProduct.getResponse());
1452 // Get Product and verify that metadata didn't change
1453 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1454 productManager1.getUserId());
1455 ProductRestUtils.checkSuccess(getProduct);
1456 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1457 expectedProduct.setUniqueId(product.getUniqueId());
1458 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1459 expectedProduct.setVersion(product.getVersion());
1460 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1461 ComponentOperationEnum.UPDATE_COMPONENT);
1464 @Test // (enabled=false)
1465 public void updateProductTagIsNull() throws Exception {
1466 createProducrByPSAndCheckIn();
1467 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1468 LifeCycleStatesEnum.CHECKOUT);
1469 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1470 productReqDetails.setUniqueId(product.getUniqueId());
1471 productReqDetails.setUUID(product.getUUID());
1472 productReqDetails.setTags(null);
1473 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1474 ProductRestUtils.checkSuccess(updateProduct);
1475 // Get Product and verify that metadata didn't change
1476 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1477 productManager1.getUserId());
1478 ProductRestUtils.checkSuccess(getProduct);
1479 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1480 expectedProduct.setUniqueId(product.getUniqueId());
1481 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1482 expectedProduct.setTags(product.getTags());
1483 expectedProduct.setVersion(product.getVersion());
1484 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1485 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1486 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1487 ComponentOperationEnum.UPDATE_COMPONENT);
1490 @Test // (enabled=false)
1491 public void updateProductTagsNameValidationProductNameIsNotInTag() throws Exception {
1492 createProducrByPSAndCheckIn();
1493 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1494 LifeCycleStatesEnum.CHECKOUT);
1495 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1496 productReqDetails.setUniqueId(product.getUniqueId());
1497 productReqDetails.setUUID(product.getUUID());
1498 productReqDetails.setTags(Arrays.asList("Abc"));
1499 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1500 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1501 updateProduct.getErrorCode().intValue());
1502 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME.name(),
1503 new ArrayList<String>(), updateProduct.getResponse());
1506 @Test // (enabled=false)
1507 public void createProductSingleTagMaxLength() throws Exception {
1508 createProducrByPSAndCheckIn();
1509 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1510 LifeCycleStatesEnum.CHECKOUT);
1511 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1512 productReqDetails.setUniqueId(product.getUniqueId());
1513 productReqDetails.setUUID(product.getUUID());
1514 productReqDetails.setTags(
1515 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
1516 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1517 ProductRestUtils.checkSuccess(updateProduct);
1518 // Get Product and verify that metadata change
1519 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1520 productManager1.getUserId());
1521 ProductRestUtils.checkSuccess(getProduct);
1522 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1523 expectedProduct.setUniqueId(product.getUniqueId());
1524 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1525 expectedProduct.setTags(productReqDetails.getTags());
1526 expectedProduct.setVersion(product.getVersion());
1527 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1528 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1529 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1530 ComponentOperationEnum.UPDATE_COMPONENT);
1533 @Test // (enabled=false)
1534 public void updateProductSingleTagExceedMaxLength() throws Exception {
1535 createProducrByPSAndCheckIn();
1536 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1537 LifeCycleStatesEnum.CHECKOUT);
1538 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1539 productReqDetails.setUniqueId(product.getUniqueId());
1540 productReqDetails.setUUID(product.getUUID());
1541 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
1542 "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"));
1543 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1544 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1545 updateProduct.getErrorCode().intValue());
1546 ArrayList<String> varibales = new ArrayList<String>();
1547 varibales.add("1024");
1548 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT.name(), varibales,
1549 updateProduct.getResponse());
1550 // Get Product and verify that metadata didn't change
1551 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1552 productManager1.getUserId());
1553 ProductRestUtils.checkSuccess(getProduct);
1554 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1555 expectedProduct.setUniqueId(product.getUniqueId());
1556 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1557 expectedProduct.setVersion(product.getVersion());
1558 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1559 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1560 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1561 ComponentOperationEnum.UPDATE_COMPONENT);
1564 @Test // (enabled=false)
1565 public void updateProductAllTagsMaxLength() throws Exception {
1566 createProducrByPSAndCheckIn();
1567 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1568 LifeCycleStatesEnum.CHECKOUT);
1569 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1570 productReqDetails.setUniqueId(product.getUniqueId());
1571 productReqDetails.setUUID(product.getUUID());
1572 productReqDetails.setTags(
1573 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1574 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1575 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1576 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1577 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1578 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1579 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607"));
1580 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1581 ProductRestUtils.checkSuccess(updateProduct);
1582 // Get Product and verify that metadata change
1583 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1584 productManager1.getUserId());
1585 ProductRestUtils.checkSuccess(getProduct);
1586 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1587 expectedProduct.setUniqueId(product.getUniqueId());
1588 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1589 expectedProduct.setTags(productReqDetails.getTags());
1590 expectedProduct.setVersion(product.getVersion());
1591 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1592 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1593 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1594 ComponentOperationEnum.UPDATE_COMPONENT);
1597 @Test // (enabled=false)
1598 public void updateProductAllTagsExceedMaxLength() throws Exception {
1599 createProducrByPSAndCheckIn();
1600 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1601 LifeCycleStatesEnum.CHECKOUT);
1602 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1603 productReqDetails.setUniqueId(product.getUniqueId());
1604 productReqDetails.setUUID(product.getUUID());
1605 productReqDetails.setTags(
1606 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1607 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1608 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1609 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1610 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1611 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1612 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
1613 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
1614 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
1615 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
1616 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
1617 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
1618 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
1619 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
1620 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
1621 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
1622 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
1623 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
1624 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
1625 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh123456"));
1626 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1627 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1628 updateProduct.getErrorCode().intValue());
1629 ArrayList<String> varibales = new ArrayList<String>();
1630 varibales.add("1024");
1631 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT.name(), varibales,
1632 updateProduct.getResponse());
1633 // Get Product and verify that metadata didn't change
1634 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1635 productManager1.getUserId());
1636 ProductRestUtils.checkSuccess(getProduct);
1637 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1638 expectedProduct.setUniqueId(product.getUniqueId());
1639 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1640 expectedProduct.setVersion(product.getVersion());
1641 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1642 ComponentOperationEnum.UPDATE_COMPONENT);
1645 @Test // (enabled=false)
1646 public void updateProductTagsDuplicateTagRemoved() throws Exception {
1647 createProducrByPSAndCheckIn();
1648 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1649 LifeCycleStatesEnum.CHECKOUT);
1650 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1651 productReqDetails.setUniqueId(product.getUniqueId());
1652 productReqDetails.setUUID(product.getUUID());
1653 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), "KoKo", "KoKo"));
1654 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1655 ProductRestUtils.checkSuccess(updateProduct);
1656 // Get Product and verify that metadata updated
1657 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1658 productManager1.getUserId());
1659 ProductRestUtils.checkSuccess(getProduct);
1660 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1661 expectedProduct.setUniqueId(product.getUniqueId());
1662 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1663 expectedProduct.setTags(Arrays.asList(productReqDetails.getName(), "KoKo"));
1664 expectedProduct.setVersion(product.getVersion());
1665 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1666 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1667 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1668 ComponentOperationEnum.UPDATE_COMPONENT);
1671 @Test // (enabled=false)
1672 public void updateProductContactsIsEmpty() throws Exception {
1673 createProducrByPSAndCheckIn();
1674 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1675 LifeCycleStatesEnum.CHECKOUT);
1676 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1677 productReqDetails.setUniqueId(product.getUniqueId());
1678 productReqDetails.setUUID(product.getUUID());
1679 productReqDetails.setContacts(Arrays.asList(""));
1680 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1681 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1682 updateProduct.getErrorCode().intValue());
1683 ArrayList<String> varibales = new ArrayList<String>();
1684 varibales.add(COMPONENT_TYPE);
1685 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_CONTACT.name(), varibales,
1686 updateProduct.getResponse());
1687 // Get Product and verify that metadata didn't change
1688 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1689 productManager1.getUserId());
1690 ProductRestUtils.checkSuccess(getProduct);
1691 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1692 expectedProduct.setUniqueId(product.getUniqueId());
1693 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1694 expectedProduct.setVersion(product.getVersion());
1695 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1696 ComponentOperationEnum.UPDATE_COMPONENT);
1699 @Test // (enabled=false)
1700 public void updateProductContactsIsNull() throws Exception {
1701 createProducrByPSAndCheckIn();
1702 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1703 LifeCycleStatesEnum.CHECKOUT);
1704 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1705 productReqDetails.setUniqueId(product.getUniqueId());
1706 productReqDetails.setUUID(product.getUUID());
1707 productReqDetails.setContacts(null);
1708 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1709 ProductRestUtils.checkSuccess(updateProduct);
1710 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1711 productManager1.getUserId());
1712 ProductRestUtils.checkSuccess(getProduct);
1713 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1714 expectedProduct.setUniqueId(product.getUniqueId());
1715 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1716 expectedProduct.setVersion(product.getVersion());
1717 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1718 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1719 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1720 ComponentOperationEnum.UPDATE_COMPONENT);
1723 @Test // (enabled=false)
1724 public void updateProductContactsInvalidFormat() throws Exception {
1725 createProducrByPSAndCheckIn();
1726 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1727 LifeCycleStatesEnum.CHECKOUT);
1728 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1729 productReqDetails.setUniqueId(product.getUniqueId());
1730 productReqDetails.setUUID(product.getUUID());
1731 productReqDetails.setContacts(Arrays.asList("bt750345"));
1732 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1733 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1734 updateProduct.getErrorCode().intValue());
1735 ArrayList<String> varibales = new ArrayList<String>();
1736 varibales.add(COMPONENT_TYPE);
1737 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_CONTACT.name(), varibales,
1738 updateProduct.getResponse());
1739 // Get Product and verify that metadata didn't change
1740 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1741 productManager1.getUserId());
1742 ProductRestUtils.checkSuccess(getProduct);
1743 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1744 expectedProduct.setUniqueId(product.getUniqueId());
1745 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1746 expectedProduct.setVersion(product.getVersion());
1747 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1748 ComponentOperationEnum.UPDATE_COMPONENT);
1751 @Test // (enabled=false)
1752 public void updateProductConvertContactsToLowerCase() throws Exception {
1753 createProducrByPSAndCheckIn();
1754 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1755 LifeCycleStatesEnum.CHECKOUT);
1756 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1757 productReqDetails.setUniqueId(product.getUniqueId());
1758 productReqDetails.setUUID(product.getUUID());
1759 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId().toUpperCase()));
1760 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1761 ProductRestUtils.checkSuccess(updateProduct);
1762 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1763 productManager1.getUserId());
1764 ProductRestUtils.checkSuccess(getProduct);
1765 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1766 expectedProduct.setUniqueId(product.getUniqueId());
1767 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1768 expectedProduct.setVersion(product.getVersion());
1769 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1770 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1772 .setContacts(Arrays.asList(productManager2.getUserId().toLowerCase(), productManager1.getUserId()));
1773 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1774 ComponentOperationEnum.UPDATE_COMPONENT);
1777 @Test // (enabled=false)
1778 public void updateProductContactsNotAllowedAsdcUsers() throws Exception {
1779 createProducrByPSAndCheckIn();
1780 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1781 LifeCycleStatesEnum.CHECKOUT);
1782 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1783 productReqDetails.setUniqueId(product.getUniqueId());
1784 productReqDetails.setUUID(product.getUUID());
1785 productReqDetails.setContacts(Arrays.asList(productStrategistUser1.getUserId()));
1786 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1787 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1788 updateProduct.getErrorCode().intValue());
1789 ArrayList<String> varibales = new ArrayList<String>();
1790 varibales.add(productStrategistUser1.getUserId());
1791 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PRODUCT_CONTACT.name(), varibales,
1792 updateProduct.getResponse());
1793 // Get Product and verify that metadata didn't change
1794 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1795 productManager1.getUserId());
1796 ProductRestUtils.checkSuccess(getProduct);
1797 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1798 expectedProduct.setUniqueId(product.getUniqueId());
1799 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1800 expectedProduct.setVersion(product.getVersion());
1801 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1802 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1803 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1804 ComponentOperationEnum.UPDATE_COMPONENT);
1807 @Test // (enabled=false)
1808 public void updateProductContactsNotAsdcUser() throws Exception {
1809 createProducrByPSAndCheckIn();
1810 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1811 LifeCycleStatesEnum.CHECKOUT);
1812 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1813 productReqDetails.setUniqueId(product.getUniqueId());
1814 productReqDetails.setUUID(product.getUUID());
1815 String nonAsdcUserUserId = "bt567h";
1816 productReqDetails.setContacts(Arrays.asList(nonAsdcUserUserId));
1817 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1818 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1819 updateProduct.getErrorCode().intValue());
1820 ArrayList<String> varibales = new ArrayList<String>();
1821 varibales.add(nonAsdcUserUserId);
1822 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PRODUCT_CONTACT.name(), varibales,
1823 updateProduct.getResponse());
1824 // Get Product and verify that metadata didn't change
1825 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1826 productManager1.getUserId());
1827 ProductRestUtils.checkSuccess(getProduct);
1828 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1829 expectedProduct.setUniqueId(product.getUniqueId());
1830 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1831 expectedProduct.setVersion(product.getVersion());
1832 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1833 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1834 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1835 ComponentOperationEnum.UPDATE_COMPONENT);
1838 @Test // (enabled=false)
1839 public void updateProductProjectCodeIsEmpty() throws Exception {
1840 createProducrByPSAndCheckIn();
1841 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1842 LifeCycleStatesEnum.CHECKOUT);
1843 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1844 productReqDetails.setUniqueId(product.getUniqueId());
1845 productReqDetails.setUUID(product.getUUID());
1846 productReqDetails.setProjectCode("");
1847 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1848 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1849 updateProduct.getErrorCode().intValue());
1850 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_PROJECT_CODE.name(), new ArrayList<String>(),
1851 updateProduct.getResponse());
1852 // Get Product and verify that metadata didn't change
1853 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1854 productManager1.getUserId());
1855 ProductRestUtils.checkSuccess(getProduct);
1856 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1857 expectedProduct.setUniqueId(product.getUniqueId());
1858 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1859 expectedProduct.setVersion(product.getVersion());
1860 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1861 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1862 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1863 ComponentOperationEnum.UPDATE_COMPONENT);
1866 @Test // (enabled=false)
1867 public void updateProductProjectCodeIsNull() throws Exception {
1868 createProducrByPSAndCheckIn();
1869 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1870 LifeCycleStatesEnum.CHECKOUT);
1871 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1872 productReqDetails.setUniqueId(product.getUniqueId());
1873 productReqDetails.setUUID(product.getUUID());
1874 productReqDetails.setProjectCode(null);
1875 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1876 ProductRestUtils.checkSuccess(updateProduct);
1877 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1878 productManager1.getUserId());
1879 ProductRestUtils.checkSuccess(getProduct);
1880 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1881 expectedProduct.setUniqueId(product.getUniqueId());
1882 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1883 expectedProduct.setVersion(product.getVersion());
1884 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1885 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1886 expectedProduct.setProjectCode(product.getProjectCode());
1887 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1888 ComponentOperationEnum.UPDATE_COMPONENT);
1891 @Test // (enabled=false)
1892 public void updateProductProjectCodeLessThanMinCharacters() throws Exception {
1893 createProducrByPSAndCheckIn();
1894 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1895 LifeCycleStatesEnum.CHECKOUT);
1896 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1897 productReqDetails.setUniqueId(product.getUniqueId());
1898 productReqDetails.setUUID(product.getUUID());
1899 productReqDetails.setProjectCode("9870");
1900 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1901 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1902 updateProduct.getErrorCode().intValue());
1903 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
1904 updateProduct.getResponse());
1905 // Get Product and verify that metadata didn't change
1906 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1907 productManager1.getUserId());
1908 ProductRestUtils.checkSuccess(getProduct);
1909 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1910 expectedProduct.setUniqueId(product.getUniqueId());
1911 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1912 expectedProduct.setVersion(product.getVersion());
1913 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1914 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1915 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1916 ComponentOperationEnum.UPDATE_COMPONENT);
1919 @Test // (enabled=false)
1920 public void updateProductProjectCodeHasnMinCharacters() throws Exception { // min
1922 createProducrByPSAndCheckIn();
1923 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1924 LifeCycleStatesEnum.CHECKOUT);
1925 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1926 productReqDetails.setUniqueId(product.getUniqueId());
1927 productReqDetails.setUUID(product.getUUID());
1928 productReqDetails.setProjectCode("98700");
1929 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1930 ProductRestUtils.checkSuccess(updateProduct);
1931 // Get Product and verify that metadata didn't change
1932 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1933 productManager1.getUserId());
1934 ProductRestUtils.checkSuccess(getProduct);
1935 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1936 expectedProduct.setUniqueId(product.getUniqueId());
1937 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1938 expectedProduct.setVersion(product.getVersion());
1939 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1940 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1941 expectedProduct.setProjectCode(productReqDetails.getProjectCode());
1942 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1943 ComponentOperationEnum.UPDATE_COMPONENT);
1946 @Test // (enabled=false)
1947 public void updateProductProjectCodeHasnMaxCharacters() throws Exception {
1948 createProducrByPSAndCheckIn();
1949 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1950 LifeCycleStatesEnum.CHECKOUT);
1951 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1952 productReqDetails.setUniqueId(product.getUniqueId());
1953 productReqDetails.setUUID(product.getUUID());
1954 productReqDetails.setProjectCode("1234567890");
1955 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1956 ProductRestUtils.checkSuccess(updateProduct);
1957 // Get Product and verify that metadata didn't change
1958 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1959 productManager1.getUserId());
1960 ProductRestUtils.checkSuccess(getProduct);
1961 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1962 expectedProduct.setUniqueId(product.getUniqueId());
1963 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1964 expectedProduct.setVersion(product.getVersion());
1965 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1966 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1967 expectedProduct.setProjectCode(productReqDetails.getProjectCode());
1968 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1969 ComponentOperationEnum.UPDATE_COMPONENT);
1972 @Test // (enabled=false)
1973 public void updateProductProjectCodeExceedMaxCharacters() throws Exception {// Max
1975 createProducrByPSAndCheckIn();
1976 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1977 LifeCycleStatesEnum.CHECKOUT);
1978 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1979 productReqDetails.setUniqueId(product.getUniqueId());
1980 productReqDetails.setUUID(product.getUUID());
1981 productReqDetails.setProjectCode("12345678901");
1982 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1983 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1984 updateProduct.getErrorCode().intValue());
1985 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
1986 updateProduct.getResponse());
1987 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1988 productManager1.getUserId());
1989 ProductRestUtils.checkSuccess(getProduct);
1990 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1991 expectedProduct.setUniqueId(product.getUniqueId());
1992 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1993 expectedProduct.setVersion(product.getVersion());
1994 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1995 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1996 expectedProduct.setProjectCode(product.getProjectCode());
1997 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1998 ComponentOperationEnum.UPDATE_COMPONENT);
2001 @Test // (enabled=false)
2002 public void updateProductProjectCodeIsNotNumeric() throws Exception {
2004 createProducrByPSAndCheckIn();
2005 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2006 LifeCycleStatesEnum.CHECKOUT);
2007 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2008 productReqDetails.setUniqueId(product.getUniqueId());
2009 productReqDetails.setUUID(product.getUUID());
2010 productReqDetails.setProjectCode("1234a");
2011 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2012 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2013 updateProduct.getErrorCode().intValue());
2014 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
2015 updateProduct.getResponse());
2016 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2017 productManager1.getUserId());
2018 ProductRestUtils.checkSuccess(getProduct);
2019 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2020 expectedProduct.setUniqueId(product.getUniqueId());
2021 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2022 expectedProduct.setVersion(product.getVersion());
2023 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2024 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2025 expectedProduct.setProjectCode(product.getProjectCode());
2026 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2027 ComponentOperationEnum.UPDATE_COMPONENT);
2030 @Test // (enabled=false)
2031 public void updateProductIconIsEmpty() throws Exception {
2032 createProducrByPSAndCheckIn();
2033 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2034 LifeCycleStatesEnum.CHECKOUT);
2035 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2036 productReqDetails.setUniqueId(product.getUniqueId());
2037 productReqDetails.setUUID(product.getUUID());
2038 productReqDetails.setIcon("");
2039 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2040 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2041 updateProduct.getErrorCode().intValue());
2042 ArrayList<String> variables = new ArrayList<String>();
2043 variables.add(COMPONENT_TYPE);
2044 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_ICON.name(), variables,
2045 updateProduct.getResponse());
2046 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2047 productManager1.getUserId());
2048 ProductRestUtils.checkSuccess(getProduct);
2049 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2050 expectedProduct.setUniqueId(product.getUniqueId());
2051 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2052 expectedProduct.setVersion(product.getVersion());
2053 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2054 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2055 expectedProduct.setIcon(product.getIcon());
2056 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2057 ComponentOperationEnum.UPDATE_COMPONENT);
2060 @Test // (enabled=false)
2061 public void updateProductIconIsNull() throws Exception {
2062 createProducrByPSAndCheckIn();
2063 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2064 LifeCycleStatesEnum.CHECKOUT);
2065 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2066 productReqDetails.setUniqueId(product.getUniqueId());
2067 productReqDetails.setUUID(product.getUUID());
2068 productReqDetails.setIcon(null);
2069 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2070 ProductRestUtils.checkSuccess(updateProduct);
2071 // Get Product and verify that metadata didn't change
2072 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2073 productManager1.getUserId());
2074 ProductRestUtils.checkSuccess(getProduct);
2075 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2076 expectedProduct.setUniqueId(product.getUniqueId());
2077 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2078 expectedProduct.setVersion(product.getVersion());
2079 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2080 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2081 expectedProduct.setIcon(product.getIcon());
2082 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2083 ComponentOperationEnum.UPDATE_COMPONENT);
2086 @Test // (enabled=false)
2087 public void updateProductIconMaxLength() throws Exception {
2088 createProducrByPSAndCheckIn();
2089 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2090 LifeCycleStatesEnum.CHECKOUT);
2091 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2092 productReqDetails.setUniqueId(product.getUniqueId());
2093 productReqDetails.setUUID(product.getUUID());
2094 productReqDetails.setIcon("A_a-1-2--b__BB1234567890A"); // Max length =
2096 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2097 ProductRestUtils.checkSuccess(updateProduct);
2098 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2099 productManager1.getUserId());
2100 ProductRestUtils.checkSuccess(getProduct);
2101 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2102 expectedProduct.setUniqueId(product.getUniqueId());
2103 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2104 expectedProduct.setVersion(product.getVersion());
2105 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2106 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2107 expectedProduct.setIcon(productReqDetails.getIcon());
2108 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2109 ComponentOperationEnum.UPDATE_COMPONENT);
2112 @Test // (enabled=false)
2113 public void updateProductIconExceedMaxLength() throws Exception {
2114 createProducrByPSAndCheckIn();
2115 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2116 LifeCycleStatesEnum.CHECKOUT);
2117 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2118 productReqDetails.setUniqueId(product.getUniqueId());
2119 productReqDetails.setUUID(product.getUUID());
2120 productReqDetails.setIcon("A_a-1-2--b__BB1234567890A_");
2121 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2122 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2123 updateProduct.getErrorCode().intValue());
2124 ArrayList<String> variables = new ArrayList<String>();
2125 variables.add(COMPONENT_TYPE);
2126 variables.add("25");
2127 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT.name(), variables,
2128 updateProduct.getResponse());
2129 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2130 productManager1.getUserId());
2131 ProductRestUtils.checkSuccess(getProduct);
2132 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2133 expectedProduct.setUniqueId(product.getUniqueId());
2134 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2135 expectedProduct.setVersion(product.getVersion());
2136 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2137 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2138 expectedProduct.setIcon(product.getIcon());
2139 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2140 ComponentOperationEnum.UPDATE_COMPONENT);
2143 @Test // (enabled=false)
2144 public void updateProductIconInValidCharacters() throws Exception {
2145 createProducrByPSAndCheckIn();
2146 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2147 LifeCycleStatesEnum.CHECKOUT);
2148 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2149 productReqDetails.setUniqueId(product.getUniqueId());
2150 productReqDetails.setUUID(product.getUUID());
2151 String icon = "asdfg"; // Allowed characters [a-zA-Z0-9], dash (‘-‘),
2152 // underscore (‘_’).
2153 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
2155 RestResponse updateProduct;
2156 for (int i = 0; i < invalidChars.length; i++) {
2157 productReqDetails.setIcon(icon + invalidChars[i]);
2158 updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2159 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2160 updateProduct.getErrorCode().intValue());
2161 ArrayList<String> variables = new ArrayList<String>();
2162 variables.add(COMPONENT_TYPE);
2163 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_ICON.name(), variables,
2164 updateProduct.getResponse());
2166 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2167 productManager1.getUserId());
2168 ProductRestUtils.checkSuccess(getProduct);
2169 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2170 expectedProduct.setUniqueId(product.getUniqueId());
2171 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2172 expectedProduct.setVersion(product.getVersion());
2173 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2174 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2175 expectedProduct.setIcon(product.getIcon());
2176 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2177 ComponentOperationEnum.UPDATE_COMPONENT);
2180 @Test // (enabled=false)
2181 public void updateProductIsActiveIsEmpty() throws Exception {
2182 createProducrByPSAndCheckIn();
2183 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2184 LifeCycleStatesEnum.CHECKOUT);
2185 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2186 productReqDetails.setUniqueId(product.getUniqueId());
2187 productReqDetails.setUUID(product.getUUID());
2188 productReqDetails.setActive("");
2189 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2190 ProductRestUtils.checkSuccess(updateProduct);
2191 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2192 productManager1.getUserId());
2193 ProductRestUtils.checkSuccess(getProduct);
2194 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2195 expectedProduct.setUniqueId(product.getUniqueId());
2196 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2197 expectedProduct.setVersion(product.getVersion());
2198 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2199 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2200 expectedProduct.setIsActive(false);
2201 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2202 ComponentOperationEnum.UPDATE_COMPONENT);
2205 @Test // (enabled=false)
2206 public void updateProductIsActiveIsTrue() throws Exception {
2207 createProducrByPSAndCheckIn();
2208 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2209 LifeCycleStatesEnum.CHECKOUT);
2210 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2211 productReqDetails.setUniqueId(product.getUniqueId());
2212 productReqDetails.setUUID(product.getUUID());
2213 productReqDetails.setActive("true");
2214 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2215 ProductRestUtils.checkSuccess(updateProduct);
2216 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2217 productManager1.getUserId());
2218 ProductRestUtils.checkSuccess(getProduct);
2219 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2220 expectedProduct.setUniqueId(product.getUniqueId());
2221 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2222 expectedProduct.setVersion(product.getVersion());
2223 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2224 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2225 expectedProduct.setIsActive(true);
2226 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2227 ComponentOperationEnum.UPDATE_COMPONENT);
2230 @Test // (enabled=false)
2231 public void updateProductIsActiveIsNull() throws Exception {
2232 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
2233 productReqDetails.setActive("true");
2234 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2235 ProductRestUtils.checkCreateResponse(createProduct);
2236 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2237 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2238 LifeCycleStatesEnum.CHECKIN);
2239 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2240 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2241 LifeCycleStatesEnum.CHECKOUT);
2242 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2243 productReqDetails.setUniqueId(product.getUniqueId());
2244 productReqDetails.setUUID(product.getUUID());
2245 productReqDetails.setActive(null);
2246 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2247 ProductRestUtils.checkSuccess(updateProduct);
2248 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2249 productManager1.getUserId());
2250 ProductRestUtils.checkSuccess(getProduct);
2251 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2252 expectedProduct.setUniqueId(product.getUniqueId());
2253 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2254 expectedProduct.setVersion(product.getVersion());
2255 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2256 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2257 expectedProduct.setIsActive(true);
2258 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2259 ComponentOperationEnum.UPDATE_COMPONENT);
2262 @Test // (enabled=false)
2263 public void updateProductIsActiveIsFalse() throws Exception {
2264 createProducrByPSAndCheckIn();
2265 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2266 LifeCycleStatesEnum.CHECKOUT);
2267 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2268 productReqDetails.setUniqueId(product.getUniqueId());
2269 productReqDetails.setUUID(product.getUUID());
2270 productReqDetails.setActive("false");
2271 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2272 ProductRestUtils.checkSuccess(updateProduct);
2273 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2274 productManager1.getUserId());
2275 ProductRestUtils.checkSuccess(getProduct);
2276 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2277 expectedProduct.setUniqueId(product.getUniqueId());
2278 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2279 expectedProduct.setVersion(product.getVersion());
2280 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2281 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2282 expectedProduct.setIsActive(false);
2283 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2284 ComponentOperationEnum.UPDATE_COMPONENT);
2287 @Test // (enabled=false)
2288 public void updateProductIsActiveHasInvalidValue() throws Exception {
2289 createProducrByPSAndCheckIn();
2290 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2291 LifeCycleStatesEnum.CHECKOUT);
2292 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2293 productReqDetails.setUniqueId(product.getUniqueId());
2294 productReqDetails.setUUID(product.getUUID());
2295 productReqDetails.setActive("eeeee");
2296 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2297 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2298 updateProduct.getErrorCode().intValue());
2299 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
2300 updateProduct.getResponse());
2301 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2302 updateProduct.getErrorCode().intValue());
2303 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2304 productManager1.getUserId());
2305 ProductRestUtils.checkSuccess(getProduct);
2306 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2307 expectedProduct.setUniqueId(product.getUniqueId());
2308 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2309 expectedProduct.setVersion(product.getVersion());
2310 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2311 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2312 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2313 ComponentOperationEnum.UPDATE_COMPONENT);
2316 @Test // (enabled=false)
2317 public void updateProductAssociations() throws Exception {
2318 createProducrByPSAndCheckIn();
2319 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2320 LifeCycleStatesEnum.CHECKOUT);
2321 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2322 productReqDetails.setUniqueId(product.getUniqueId());
2323 productReqDetails.setUUID(product.getUUID());
2324 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
2325 productReqDetails.setCategories(addSecondGroupingToDefaultCategory);
2326 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2327 ProductRestUtils.checkSuccess(updateProduct);
2328 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2329 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2330 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2331 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2332 expectedProduct.setUUID(product.getUUID());
2333 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2334 expectedProduct.setCategories(productReqDetails.getCategories());
2335 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2336 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2337 ComponentOperationEnum.UPDATE_COMPONENT);
2340 @Test // (enabled=false)
2341 public void updateProductAssociations02() throws Exception {
2342 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory(); // Category1->Subcategory1->[Grouping1,
2344 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(addSecondGroupingToDefaultCategory);
2345 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2346 ProductRestUtils.checkCreateResponse(createProduct);
2347 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2348 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2349 LifeCycleStatesEnum.CHECKIN);
2350 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2351 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2352 LifeCycleStatesEnum.CHECKOUT);
2353 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2354 productReqDetails.setUniqueId(product.getUniqueId());
2355 productReqDetails.setUUID(product.getUUID());
2356 List<CategoryDefinition> defaultCategory = addSubcategoryAndGroupingToDefaultCategory(); // Category1->[Subcategory1->[Grouping1,
2357 // Grouping11],Subcategory2->[Grouping12]]
2358 productReqDetails.setCategories(defaultCategory);
2359 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2360 ProductRestUtils.checkSuccess(updateProduct);
2361 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2362 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2363 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2364 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2365 expectedProduct.setUUID(product.getUUID());
2366 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2367 expectedProduct.setCategories(productReqDetails.getCategories());
2368 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2369 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2370 ComponentOperationEnum.UPDATE_COMPONENT);
2373 @Test // (enabled=false)
2374 public void updateProductRemoveAllAssociations() throws Exception {
2375 createProducrByPSAndCheckIn();
2376 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2377 LifeCycleStatesEnum.CHECKOUT);
2378 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2379 productReqDetails.setUniqueId(product.getUniqueId());
2380 productReqDetails.setUUID(product.getUUID());
2381 List<CategoryDefinition> defaultCategory = new ArrayList<CategoryDefinition>();
2382 productReqDetails.setCategories(defaultCategory);
2383 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2384 ProductRestUtils.checkSuccess(updateProduct);
2385 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2386 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2387 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2388 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2389 expectedProduct.setUUID(product.getUUID());
2390 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2391 expectedProduct.setCategories(productReqDetails.getCategories());
2392 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2393 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2394 ComponentOperationEnum.UPDATE_COMPONENT);
2397 @Test // (enabled=false)
2398 public void updateProductAssociationsCategotyIsNull() throws Exception {
2399 createProducrByPSAndCheckIn();
2400 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2401 LifeCycleStatesEnum.CHECKOUT);
2402 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2403 productReqDetails.setUniqueId(product.getUniqueId());
2404 productReqDetails.setUUID(product.getUUID());
2405 productReqDetails.setCategories(null);// product categories will not be
2407 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2408 ProductRestUtils.checkSuccess(updateProduct);
2409 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2410 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2411 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2412 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2413 expectedProduct.setUUID(product.getUUID());
2414 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2415 expectedProduct.setCategories(product.getCategories());
2416 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2417 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2418 ComponentOperationEnum.UPDATE_COMPONENT);
2421 ////////////////////////////////////////////////////////////////////////
2423 private void createProductWithCategories(List<CategoryDefinition> categoryDefinitions) throws Exception {
2424 ProductReqDetails productReqDetails = (categoryDefinitions != null
2425 ? ElementFactory.getDefaultProduct(categoryDefinitions) : ElementFactory.getDefaultProduct());
2426 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2427 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
2428 createProduct.getErrorCode().intValue());
2429 Product actualProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2430 String actualUuid = ResponseParser.getUuidFromResponse(createProduct);
2431 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
2433 String normalizedNameFomJsonResponse = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
2435 expectedProduct.setNormalizedName(normalizedNameFomJsonResponse);
2436 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2437 ComponentOperationEnum.CREATE_COMPONENT);
2438 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
2439 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
2440 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, actualUuid);
2441 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
2444 private void createProducrByPSAndCheckIn() throws Exception {
2445 productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
2446 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2447 ProductRestUtils.checkCreateResponse(createProduct);
2448 product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2449 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2450 LifeCycleStatesEnum.CHECKIN);
2451 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2455 public void checkInvariantUuidIsImmutable() throws Exception {
2456 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
2457 String invariantUuidDefinedByUser = "!!!!!!!!!!!!!!!!!!!!!!!!";
2458 productReqDetails.setInvariantUUID(invariantUuidDefinedByUser);
2459 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2460 BaseRestUtils.checkStatusCode(createProduct, "create request failed", false, 201);
2461 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
2462 createProduct.getErrorCode().intValue());
2463 Product ProductCreation = ResponseParser.convertProductResponseToJavaObject(createProduct.getResponse());
2464 String invariantUUIDcreation = ProductCreation.getInvariantUUID();
2466 // validate get response
2467 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2468 productManager1.getUserId());
2469 BaseRestUtils.checkSuccess(getProductRes);
2470 Product productGetting = ResponseParser.convertProductResponseToJavaObject(getProductRes.getResponse());
2471 String invariantUUIDgetting = productGetting.getInvariantUUID();
2472 assertEquals(invariantUUIDcreation, invariantUUIDgetting);
2474 // Update Product with new invariant UUID
2475 RestResponse restResponseUpdate = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2476 BaseRestUtils.checkSuccess(restResponseUpdate);
2477 Product updatedProduct = ResponseParser.convertProductResponseToJavaObject(restResponseUpdate.getResponse());
2478 String invariantUUIDupdating = updatedProduct.getInvariantUUID();
2479 assertEquals(invariantUUIDcreation, invariantUUIDupdating);
2482 RestResponse restResponseCheckin = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2483 LifeCycleStatesEnum.CHECKIN);
2484 BaseRestUtils.checkSuccess(restResponseCheckin);
2485 Product checkinProduct = ResponseParser.convertProductResponseToJavaObject(restResponseCheckin.getResponse());
2486 String invariantUUIDcheckin = checkinProduct.getInvariantUUID();
2487 String version = checkinProduct.getVersion();
2488 assertEquals(invariantUUIDcreation, invariantUUIDcheckin);
2489 assertEquals(version, "0.1");
2492 RestResponse restResponseCheckout = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2493 LifeCycleStatesEnum.CHECKOUT);
2494 BaseRestUtils.checkSuccess(restResponseCheckout);
2495 Product checkoutProduct = ResponseParser.convertProductResponseToJavaObject(restResponseCheckout.getResponse());
2496 String invariantUUIDcheckout = checkoutProduct.getInvariantUUID();
2497 version = checkoutProduct.getVersion();
2498 assertEquals(invariantUUIDcreation, invariantUUIDcheckout);
2499 assertEquals(version, "0.2");
2504 private void getProductValidateInvariantUuid(String productUniqueId, String invariantUUIDcreation)
2506 RestResponse getProduct = ProductRestUtils.getProduct(productUniqueId,
2507 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId());
2508 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, getProduct.getErrorCode().intValue());
2509 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(getProduct));
2512 @Test // invariantUUID generated when the component is created and never
2514 public void productInvariantUuid() throws Exception {
2515 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
2516 String invariantUuidDefinedByUser = "12345";
2517 productReqDetails.setInvariantUUID(invariantUuidDefinedByUser);
2518 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2519 assertEquals("Check response code after create resource", BaseRestUtils.STATUS_CODE_CREATED,
2520 createProduct.getErrorCode().intValue());
2521 // invariantUUID generated when the component is created and never
2523 String invariantUUIDcreation = ResponseParser.getInvariantUuid(createProduct);
2524 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2525 // Update Product with new invariant UUID
2526 RestResponse restResponse = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2527 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2528 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2530 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2531 LifeCycleStatesEnum.CHECKIN);
2532 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2533 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2534 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2536 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2537 LifeCycleStatesEnum.CHECKOUT);
2538 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2539 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2540 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2543 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2544 LifeCycleStatesEnum.UNDOCHECKOUT);
2545 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2546 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2547 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);