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.assertTrue;
26 import java.util.Arrays;
28 import org.json.JSONArray;
29 import org.json.JSONException;
30 import org.junit.Rule;
31 import org.junit.rules.TestName;
32 import org.openecomp.sdc.be.dao.api.ActionStatus;
33 import org.openecomp.sdc.be.model.LifecycleStateEnum;
34 import org.openecomp.sdc.be.model.Product;
35 import org.openecomp.sdc.be.model.User;
36 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
37 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
38 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedProductAudit;
39 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
40 import org.openecomp.sdc.ci.tests.utils.DbUtils;
41 import org.openecomp.sdc.ci.tests.utils.Utils;
42 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
43 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
44 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
45 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
46 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
47 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
48 import org.openecomp.sdc.ci.tests.utils.validation.ProductValidationUtils;
49 import org.openecomp.sdc.common.api.Constants;
50 import org.testng.annotations.Test;
52 public class ProductCreateWithValidationsTest extends ProductBaseTest {
54 public static TestName name = new TestName();
56 public static String INITIAL_PRODUCT_VERSION = "0.1";
57 public static String CREATE_AUDIT_ACTION = "Create";
58 public String normalizedName;
60 public ProductCreateWithValidationsTest() {
61 super(name, ProductCreateWithValidationsTest.class.getName());
64 @Test // (enabled = false)
65 public void createProductSuccessValidation() throws Exception {
66 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
67 // productReqDetails.setName("CIProduct1");
68 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
69 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
70 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
71 ProductRestUtils.checkCreateResponse(createProduct);
72 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
73 compareExpectedAndActualProducts(productReqDetails, createProduct);
74 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
75 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
76 productManager1.getUserId());
77 ProductRestUtils.checkSuccess(getProductRes);
78 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
79 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
80 ComponentOperationEnum.GET_COMPONENT);
81 assertEquals(actualProduct.getIsActive(), new Boolean(false));
82 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
83 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
84 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
85 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
89 public void createProductNotByPmUser() throws Exception {
90 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
91 // productReqDetails.setName("CIProduct1");
92 normalizedName = productReqDetails.getName().toLowerCase();
93 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productStrategistUser1);
94 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
95 createProduct.getErrorCode().intValue());
96 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
97 productStrategistUser1);
98 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
99 expectedProduct, CREATE_AUDIT_ACTION, productStrategistUser1, ActionStatus.RESTRICTED_OPERATION,
100 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
101 constructFieldsForAuditValidation.setCURR_VERSION("");
102 constructFieldsForAuditValidation.setCURR_STATE("");
103 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
107 public void createProductNotByAsdcUser() throws Exception {
108 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
109 nonAsdcUser.setUserId("bt750k");
110 nonAsdcUser.setFirstName(null);
111 nonAsdcUser.setLastName(null);
112 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
113 // productReqDetails.setName("CIProduct1");
114 normalizedName = productReqDetails.getName().toLowerCase();
115 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, nonAsdcUser);
116 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
117 createProduct.getErrorCode().intValue());
118 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
120 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
121 expectedProduct, CREATE_AUDIT_ACTION, nonAsdcUser, ActionStatus.RESTRICTED_OPERATION,
122 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
123 constructFieldsForAuditValidation.setCURR_VERSION("");
124 constructFieldsForAuditValidation.setCURR_STATE("");
125 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
129 public void createProductUserIdIsEmpty() throws Exception {
130 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
131 nonAsdcUser.setUserId("");
132 nonAsdcUser.setFirstName(null);
133 nonAsdcUser.setLastName(null);
134 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
135 // productReqDetails.setName("CIProduct1");
136 normalizedName = productReqDetails.getName().toLowerCase();
137 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, nonAsdcUser);
138 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
139 createProduct.getErrorCode().intValue());
140 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
142 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
143 expectedProduct, CREATE_AUDIT_ACTION, nonAsdcUser, ActionStatus.MISSING_INFORMATION,
144 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
145 constructFieldsForAuditValidation.setCURR_VERSION("");
146 constructFieldsForAuditValidation.setCURR_STATE("");
147 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
151 public void createProductNameValidationLessThanMinCharacters() throws Exception {
152 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
153 productReqDetails.setName("Pro");
154 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
155 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
156 createProduct.getErrorCode().intValue());
157 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
158 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
159 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
160 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
161 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
162 constructFieldsForAuditValidation.setCURR_VERSION("");
163 constructFieldsForAuditValidation.setCURR_STATE("");
164 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
167 @Test // (enabled = false)
168 public void createProductNameValidationMaxLength() throws Exception {
170 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
171 // productReqDetails.setName("Qwertyuiop1234567890asdfA");
172 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
173 normalizedName = productReqDetails.getName().toLowerCase();
174 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
175 ProductRestUtils.checkCreateResponse(createProduct);
176 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
177 compareExpectedAndActualProducts(productReqDetails, createProduct);
178 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
179 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
180 productManager1.getUserId());
181 ProductRestUtils.checkSuccess(getProductRes);
182 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
183 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
184 ComponentOperationEnum.GET_COMPONENT);
185 assertEquals(actualProduct.getIsActive(), new Boolean(false));
186 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
187 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
188 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
189 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
193 public void createProductNameValidationExceedMaxLength() throws Exception {
195 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
196 productReqDetails.setName("Qwertyuiop1234567890asdfAa");
197 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
198 normalizedName = productReqDetails.getName().toLowerCase();
199 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
200 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
201 createProduct.getErrorCode().intValue());
202 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
203 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
204 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
205 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
206 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
207 constructFieldsForAuditValidation.setCURR_VERSION("");
208 constructFieldsForAuditValidation.setCURR_STATE("");
209 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
213 public void createProductNameValidationEmptyName() throws Exception {
214 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
215 productReqDetails.setName("");
216 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
217 normalizedName = productReqDetails.getName().toLowerCase();
218 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
219 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
220 createProduct.getErrorCode().intValue());
221 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
222 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
223 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
224 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
226 constructFieldsForAuditValidation.setCURR_VERSION("");
227 constructFieldsForAuditValidation.setCURR_STATE("");
228 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
231 @Test // (enabled = false)
232 public void createProductNameAlreadyExist() throws Exception {
233 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
234 // productReqDetails.setName("CIProduct1");
235 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
236 normalizedName = productReqDetails.getName().toLowerCase();
237 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
238 ProductRestUtils.checkCreateResponse(createProduct);
239 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
240 normalizedName = productReqDetails.getName().toLowerCase();
241 // // productReqDetails.setName("CIProduct1");
242 DbUtils.deleteFromEsDbByPattern("_all");
243 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
244 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_ALREADY_EXISTS,
245 createProduct.getErrorCode().intValue());
246 productReqDetails.setVersion("0.1");
247 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
248 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
249 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
250 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
251 productReqDetails.getName());
252 constructFieldsForAuditValidation.setCURR_VERSION("0.1");
253 constructFieldsForAuditValidation.setCURR_STATE("");
254 constructFieldsForAuditValidation.setCURR_STATE("NOT_CERTIFIED_CHECKOUT");
255 constructFieldsForAuditValidation.setSERVICE_INSTANCE_ID(null);
256 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
260 public void createProductNameValidationNameIsNull() throws Exception {
261 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
262 productReqDetails.setName(null);
263 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
264 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
265 createProduct.getErrorCode().intValue());
266 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
267 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
268 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
269 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
271 constructFieldsForAuditValidation.setCURR_VERSION("");
272 constructFieldsForAuditValidation.setCURR_STATE("");
273 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
277 @Test (enabled = false)
278 public void createProductNameValidationAllowedCharacters() throws Exception {
279 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
280 productReqDetails.setName("Ci_2@3:4& m=n+b-u.j-u'g#b"); // Bug @:&=+'#
281 normalizedName = "ci234mnbujugb";
282 String expectedProductName = "Ci_2@3:4& M=n+b-u.j-u'g#b";
283 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
284 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
285 ProductRestUtils.checkCreateResponse(createProduct);
286 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
287 productReqDetails.setName(expectedProductName);
288 productReqDetails.setName("Ci_2@3:4& M=n+b-u.j-u'g#b");
289 compareExpectedAndActualProducts(productReqDetails, createProduct);
290 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
291 expectedProduct.setNormalizedName(normalizedName);
292 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
293 productManager1.getUserId());
294 ProductRestUtils.checkSuccess(getProductRes);
295 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
296 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
297 ComponentOperationEnum.GET_COMPONENT);
298 assertEquals(actualProduct.getIsActive(), new Boolean(false));
299 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
300 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
301 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
302 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
307 public void createProductNameValidationREmoveExtraNonAlphanumericChars() throws Exception {
308 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
309 productReqDetails.setName("Ci____222----333......asd");
310 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
311 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
312 ProductRestUtils.checkCreateResponse(createProduct);
313 productReqDetails.setName("Ci_222-333.asd");
314 normalizedName = "ci222333asd";
315 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
316 compareExpectedAndActualProducts(productReqDetails, createProduct);
317 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
318 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
319 productManager1.getUserId());
320 ProductRestUtils.checkSuccess(getProductRes);
321 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
322 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
323 ComponentOperationEnum.GET_COMPONENT);
324 assertEquals(actualProduct.getIsActive(), new Boolean(false));
325 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
326 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
327 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
328 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
332 public void createProductNameValidationNotAllowedCharacters() throws Exception {
333 ExpectedProductAudit constructFieldsForAuditValidation;
334 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
336 for (int i = 0; i < invalidChars.length; i++) {
337 DbUtils.deleteFromEsDbByPattern("_all");
338 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
339 productReqDetails.setName("abc" + invalidChars[i]);
340 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
341 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
342 createProduct.getErrorCode().intValue());
343 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "",
345 constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(expectedProduct,
346 CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT,
347 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
349 constructFieldsForAuditValidation.setCURR_VERSION("");
350 constructFieldsForAuditValidation.setCURR_STATE("");
351 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
356 public void createProductFullNameContainSpecialCharacters() throws Exception {
357 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
359 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
360 for (int i = 0; i < invalidChars.length; i++) {
361 DbUtils.deleteFromEsDbByPattern("_all");
362 productReqDetails.setFullName("abc" + invalidChars[i]);
363 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
364 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_CREATED,
365 createProduct.getErrorCode().intValue());
366 RestResponse deleteProduct = ProductRestUtils.deleteProduct(productReqDetails.getUniqueId(),
367 productManager1.getUserId());
368 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
369 deleteProduct.getErrorCode().intValue());
373 // Already enabled = false
375 public void createProductNameValidationRemoveSpaceFromBeginning() throws Exception {
376 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
377 productReqDetails.setName(" Ciertyuiop1234567890asdfA");
378 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
379 normalizedName = productReqDetails.getName().trim().toLowerCase();
380 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
381 ProductRestUtils.checkCreateResponse(createProduct);
382 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
383 productReqDetails.setName(" Ciertyuiop1234567890asdfA".trim());
384 compareExpectedAndActualProducts(productReqDetails, createProduct);
385 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
386 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
387 productManager1.getUserId());
388 ProductRestUtils.checkSuccess(getProductRes);
389 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
390 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
391 ComponentOperationEnum.GET_COMPONENT);
392 assertEquals(actualProduct.getIsActive(), new Boolean(false));
393 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
394 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
395 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
396 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
399 // Already enabled = false
401 public void createProductNameValidationRemoveSpaceFromTheEnd() throws Exception {
402 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
403 productReqDetails.setName("Ciertyuiop1234567890asdfA ");
404 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
405 normalizedName = productReqDetails.getName().trim().toLowerCase();
406 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
407 ProductRestUtils.checkCreateResponse(createProduct);
408 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
409 productReqDetails.setName("Ciertyuiop1234567890asdfA ".trim());
410 compareExpectedAndActualProducts(productReqDetails, createProduct);
411 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
412 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
413 productManager1.getUserId());
414 ProductRestUtils.checkSuccess(getProductRes);
415 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
416 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
417 ComponentOperationEnum.GET_COMPONENT);
418 assertEquals(actualProduct.getIsActive(), new Boolean(false));
419 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
420 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
421 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
422 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
426 public void createProductNameValidationStartWithNumber() throws Exception {
427 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
428 productReqDetails.setName("1Qwert");
429 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
430 normalizedName = productReqDetails.getName().trim().toLowerCase();
431 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
432 ProductRestUtils.checkCreateResponse(createProduct);
433 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
434 compareExpectedAndActualProducts(productReqDetails, createProduct);
435 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
436 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
437 productManager1.getUserId());
438 ProductRestUtils.checkSuccess(getProductRes);
439 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
440 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
441 ComponentOperationEnum.GET_COMPONENT);
442 assertEquals(actualProduct.getIsActive(), new Boolean(false));
443 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
444 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
445 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
446 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
447 productReqDetails.setName("Ci1Qwert");
448 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
453 public void createProductNameValidationStartWithNonAlphaNumeric() throws Exception {
454 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
455 productReqDetails.setName("_Qwert");
456 productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
457 normalizedName = productReqDetails.getName().trim().toLowerCase();
458 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
459 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
460 createProduct.getErrorCode().intValue());
461 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
462 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
463 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
464 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
465 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
466 constructFieldsForAuditValidation.setCURR_VERSION("");
467 constructFieldsForAuditValidation.setCURR_STATE("");
468 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
471 @Test // (enabled = false)
472 public void createProductNameValidationFirstLetterOfKeyWordsCapitalized() throws Exception {
473 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
474 // productReqDetails.setName("Abba");
475 // productReqDetails.setTags(Arrays.asList("abba"));
476 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
477 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
478 ProductRestUtils.checkCreateResponse(createProduct);
479 // // productReqDetails.setName("Abba");
481 * String actualNormalizedNameFromResponse =
482 * ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
484 * assertTrue(actualNormalizedNameFromResponse.equals(normalizedName));
486 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
487 compareExpectedAndActualProducts(productReqDetails, createProduct);
488 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
489 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
490 productManager1.getUserId());
491 ProductRestUtils.checkSuccess(getProductRes);
492 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
493 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
494 ComponentOperationEnum.GET_COMPONENT);
495 assertEquals(actualProduct.getIsActive(), new Boolean(false));
496 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
497 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
498 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
499 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
503 public void createProductFullNameValidationIsEmpty() throws Exception {
504 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
505 productReqDetails.setFullName("");
506 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
507 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
508 createProduct.getErrorCode().intValue());
509 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
510 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
511 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
512 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "full");
513 constructFieldsForAuditValidation.setCURR_VERSION("");
514 constructFieldsForAuditValidation.setCURR_STATE("");
515 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
519 public void createProductFullNameValidationIsNull() throws Exception {
520 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
521 productReqDetails.setFullName("");
522 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
523 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
524 createProduct.getErrorCode().intValue());
525 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
526 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
527 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
528 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "full");
529 constructFieldsForAuditValidation.setCURR_VERSION("");
530 constructFieldsForAuditValidation.setCURR_STATE("");
531 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
535 public void createProductFullNameLessThanMinLength() throws Exception {
536 // Min is 4 characters
537 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
538 productReqDetails.setFullName("abc");
539 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
540 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
541 createProduct.getErrorCode().intValue());
542 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
543 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
544 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
545 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
546 null, null, Constants.EMPTY_STRING, "Product", "full");
547 constructFieldsForAuditValidation.setCURR_VERSION("");
548 constructFieldsForAuditValidation.setCURR_STATE("");
549 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
552 @Test // (enabled = false)
553 public void createProductFullNameHasMinLength() throws Exception {
554 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
555 // productReqDetails.setName("Abba");
556 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
557 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
558 productReqDetails.setFullName("abcd");
559 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
560 ProductRestUtils.checkCreateResponse(createProduct);
561 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
562 compareExpectedAndActualProducts(productReqDetails, createProduct);
563 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
564 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
565 productManager1.getUserId());
566 ProductRestUtils.checkSuccess(getProductRes);
567 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
568 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
569 ComponentOperationEnum.GET_COMPONENT);
570 assertEquals(actualProduct.getIsActive(), new Boolean(false));
571 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
572 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
573 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
574 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
577 @Test // (enabled = false)
578 public void createProductFullNameHasMaxLength() throws Exception {
579 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
580 // productReqDetails.setName("Abba");
581 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
582 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
583 productReqDetails.setFullName(
584 "Abba1234567890asdfghjk l123zxcvbnm432adfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12");
585 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
586 ProductRestUtils.checkCreateResponse(createProduct);
587 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
588 compareExpectedAndActualProducts(productReqDetails, createProduct);
589 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
590 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
591 productManager1.getUserId());
592 ProductRestUtils.checkSuccess(getProductRes);
593 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
594 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
595 ComponentOperationEnum.GET_COMPONENT);
596 assertEquals(actualProduct.getIsActive(), new Boolean(false));
597 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
598 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
599 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
600 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
603 @Test // (enabled = false)
604 public void createProductFullNameExceedMaxLength() throws Exception {
605 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
606 // productReqDetails.setName("Abba");
607 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
608 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
609 productReqDetails.setFullName(
610 "Abba1234567890asdfghjk l123zxcvbnm432adfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.123");
611 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
612 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
613 createProduct.getErrorCode().intValue());
614 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
615 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
616 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
617 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
618 null, null, Constants.EMPTY_STRING, "Product", "full");
619 constructFieldsForAuditValidation.setCURR_VERSION("");
620 constructFieldsForAuditValidation.setCURR_STATE("");
621 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
624 @Test // (enabled = false)
625 public void createProductFullNameRemoveExtraSpaces() throws Exception {
626 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
627 // productReqDetails.setName("Abba");
628 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
629 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
630 productReqDetails.setFullName("Abbaaa a1");
631 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
632 ProductRestUtils.checkCreateResponse(createProduct);
633 productReqDetails.setFullName("Abbaaa a1");
634 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
635 compareExpectedAndActualProducts(productReqDetails, createProduct);
636 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
637 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
638 productManager1.getUserId());
639 ProductRestUtils.checkSuccess(getProductRes);
640 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
641 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
642 ComponentOperationEnum.GET_COMPONENT);
643 assertEquals(actualProduct.getIsActive(), new Boolean(false));
644 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
645 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
646 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
647 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
651 public void createProductDescriptionValidationIsEmpty() throws Exception {
652 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
653 productReqDetails.setDescription("");
654 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
655 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
656 createProduct.getErrorCode().intValue());
657 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
658 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
659 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
660 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
661 constructFieldsForAuditValidation.setCURR_VERSION("");
662 constructFieldsForAuditValidation.setCURR_STATE("");
663 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
667 public void createProductDescriptionValidationIsNull() throws Exception {
668 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
669 productReqDetails.setDescription(null);
670 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
671 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
672 createProduct.getErrorCode().intValue());
673 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
674 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
675 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
676 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
677 constructFieldsForAuditValidation.setCURR_VERSION("");
678 constructFieldsForAuditValidation.setCURR_STATE("");
679 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
682 @Test (enabled = false)
683 public void createProductDescriptionValidCharacters01() throws Exception {
684 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
685 // productReqDetails.setName("Abba");
686 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
687 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
688 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
689 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
690 ProductRestUtils.checkCreateResponse(createProduct);
691 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890Bold<");
692 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
693 compareExpectedAndActualProducts(productReqDetails, createProduct);
694 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
695 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
696 productManager1.getUserId());
697 ProductRestUtils.checkSuccess(getProductRes);
698 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
699 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
700 ComponentOperationEnum.GET_COMPONENT);
701 assertEquals(actualProduct.getIsActive(), new Boolean(false));
702 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
703 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
704 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
705 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
708 @Test (enabled = false)
709 public void createProductDescriptionValidCharacters02() throws Exception {
710 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
711 // productReqDetails.setName("Abba");
712 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
713 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
714 productReqDetails.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
715 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
716 ProductRestUtils.checkCreateResponse(createProduct);
717 productReqDetails.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
718 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
719 compareExpectedAndActualProducts(productReqDetails, createProduct);
720 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
721 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
722 productManager1.getUserId());
723 ProductRestUtils.checkSuccess(getProductRes);
724 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
725 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
726 ComponentOperationEnum.GET_COMPONENT);
727 assertEquals(actualProduct.getIsActive(), new Boolean(false));
728 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
729 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
730 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
731 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
734 @Test // (enabled = false)
735 public void createProductDescriptionInValidCharacters() throws Exception {
736 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
737 // productReqDetails.setName("Abba");
738 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
739 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
740 productReqDetails.setDescription("מה");
741 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
742 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
743 createProduct.getErrorCode().intValue());
744 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
745 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
746 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_DESCRIPTION,
747 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
748 constructFieldsForAuditValidation.setCURR_VERSION("");
749 constructFieldsForAuditValidation.setCURR_STATE("");
750 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
753 @Test (enabled = false)
754 public void createProductDescriptionRemoveSpacesFromBeginning() throws Exception {
755 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
756 // productReqDetails.setName("Abba");
757 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
758 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
759 productReqDetails.setDescription(" abcd12345");
760 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
761 ProductRestUtils.checkCreateResponse(createProduct);
762 productReqDetails.setDescription("abcd12345");
763 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
764 compareExpectedAndActualProducts(productReqDetails, createProduct);
765 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
766 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
767 productManager1.getUserId());
768 ProductRestUtils.checkSuccess(getProductRes);
769 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
770 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
771 ComponentOperationEnum.GET_COMPONENT);
772 assertEquals(actualProduct.getIsActive(), new Boolean(false));
773 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
774 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
775 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
776 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
779 @Test (enabled = false)
780 public void createProductDescriptionRemoveSpacesFromTheEnd() throws Exception {
781 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
782 // productReqDetails.setName("Abba");
783 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
784 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
785 productReqDetails.setDescription("abcd 12345 xcvb ");
786 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
787 ProductRestUtils.checkCreateResponse(createProduct);
788 productReqDetails.setDescription("abcd 12345 xcvb");
789 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
790 compareExpectedAndActualProducts(productReqDetails, createProduct);
791 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
792 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
793 productManager1.getUserId());
794 ProductRestUtils.checkSuccess(getProductRes);
795 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
796 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
797 ComponentOperationEnum.GET_COMPONENT);
798 assertEquals(actualProduct.getIsActive(), new Boolean(false));
799 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
800 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
801 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
802 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
805 @Test // (enabled = false)
806 public void createProductDescriptionMaxLength() throws Exception {
807 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
808 // productReqDetails.setName("Abba");
809 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
810 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
811 productReqDetails.setDescription(
812 "Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12asdfghjklzxcvbnmqwertyui");
813 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
814 ProductRestUtils.checkCreateResponse(createProduct);
815 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
816 compareExpectedAndActualProducts(productReqDetails, createProduct);
817 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
818 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
819 productManager1.getUserId());
820 ProductRestUtils.checkSuccess(getProductRes);
821 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
822 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
823 ComponentOperationEnum.GET_COMPONENT);
824 assertEquals(actualProduct.getIsActive(), new Boolean(false));
825 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
826 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
827 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
828 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
831 @Test // (enabled = false)
832 public void createProductDescriptionExceedMaxLength() throws Exception {
833 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
834 // productReqDetails.setName("Abba");
835 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
836 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
837 productReqDetails.setDescription(
838 "Abxba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12asdfghjklzxcvbnmqwertyui");
839 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
840 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
841 createProduct.getErrorCode().intValue());
842 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
843 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
844 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT,
845 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "1024");
846 constructFieldsForAuditValidation.setCURR_VERSION("");
847 constructFieldsForAuditValidation.setCURR_STATE("");
848 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
852 public void createProductTagIsEmpty() throws Exception {
853 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
854 productReqDetails.setName("Product");
855 productReqDetails.setTags(Arrays.asList(""));
856 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
857 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
858 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
859 createProduct.getErrorCode().intValue());
860 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
861 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
862 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_FIELD_FORMAT,
863 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "tag");
864 constructFieldsForAuditValidation.setCURR_VERSION("");
865 constructFieldsForAuditValidation.setCURR_STATE("");
866 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
870 @Test // (enabled = false)
871 public void createProductTagValidationAllowedCharacters() throws Exception {
872 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
873 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
874 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), "Acde2@3:4& m=n+b-u.j-u'g#b"));
875 normalizedName = productReqDetails.getName().toLowerCase();
876 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
877 ProductRestUtils.checkCreateResponse(createProduct);
878 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
879 compareExpectedAndActualProducts(productReqDetails, createProduct);
880 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
881 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
882 productManager1.getUserId());
883 ProductRestUtils.checkSuccess(getProductRes);
884 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
885 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
886 ComponentOperationEnum.GET_COMPONENT);
887 assertEquals(actualProduct.getIsActive(), new Boolean(false));
888 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
889 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
890 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
891 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
894 @Test // (enabled = false)
895 public void createProductTagsNameValidationProductNameIsNotInTag() throws Exception {
896 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
897 // productReqDetails.setName("Qwertyuiop1234567890asdfA");
898 productReqDetails.setTags(Arrays.asList("Abc"));
899 normalizedName = productReqDetails.getName().trim().toLowerCase();
900 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
901 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
902 createProduct.getErrorCode().intValue());
903 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
904 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
905 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME,
906 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
907 constructFieldsForAuditValidation.setCURR_VERSION("");
908 constructFieldsForAuditValidation.setCURR_STATE("");
909 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
912 @Test // (enabled = false)
913 public void createProductSingleTagMaxLength() throws Exception {
914 // SingleTagMaxLength = 50
915 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
916 // productReqDetails.setName("CIProduct1");
917 productReqDetails.setTags(
918 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
919 normalizedName = productReqDetails.getName().toLowerCase();
920 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
921 ProductRestUtils.checkCreateResponse(createProduct);
922 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
923 compareExpectedAndActualProducts(productReqDetails, createProduct);
924 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
925 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
926 productManager1.getUserId());
927 ProductRestUtils.checkSuccess(getProductRes);
928 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
929 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
930 ComponentOperationEnum.GET_COMPONENT);
931 assertEquals(actualProduct.getIsActive(), new Boolean(false));
932 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
933 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
934 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
935 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
938 @Test (enabled = false)
939 public void createProductSingleTagExceedMaxLength() throws Exception {
940 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
941 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
942 productReqDetails.setTags(
943 Arrays.asList(productReqDetails.getName(), "Axbba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
944 normalizedName = productReqDetails.getName().toLowerCase();
945 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
946 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
947 createProduct.getErrorCode().intValue());
948 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
949 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
950 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT,
951 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "50");
952 constructFieldsForAuditValidation.setCURR_VERSION("");
953 constructFieldsForAuditValidation.setCURR_STATE("");
954 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
957 @Test (enabled = false)
958 public void createProductAllTagsMaxLength() throws Exception {
959 // AllTagsMaxLength = 1024
960 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
961 // productReqDetails.setName("CIProduct1");
962 productReqDetails.setTags(
963 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
964 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
965 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
966 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
967 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
968 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
969 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
970 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
971 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
972 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
973 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
974 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
975 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
976 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
977 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
978 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
979 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
980 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
981 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
982 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345"));
983 normalizedName = productReqDetails.getName().toLowerCase();
984 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
985 ProductRestUtils.checkCreateResponse(createProduct);
986 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
987 compareExpectedAndActualProducts(productReqDetails, createProduct);
988 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
989 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
990 productManager1.getUserId());
991 ProductRestUtils.checkSuccess(getProductRes);
992 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
993 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
994 ComponentOperationEnum.GET_COMPONENT);
995 assertEquals(actualProduct.getIsActive(), new Boolean(false));
996 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
997 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
998 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
999 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1003 public void createProductAllTagsExceedMaxLength() throws Exception {
1004 // AllTagsMaxLength = 1024
1005 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1006 // productReqDetails.setName("CIProduct1");
1007 productReqDetails.setTags(
1008 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1009 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1010 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1011 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1012 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1013 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1014 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
1015 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
1016 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
1017 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
1018 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
1019 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
1020 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
1021 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
1022 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
1023 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
1024 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
1025 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
1026 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
1027 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh123456"));
1028 normalizedName = productReqDetails.getName().toLowerCase();
1029 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1030 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1031 createProduct.getErrorCode().intValue());
1032 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1033 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1034 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT,
1035 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "1024");
1036 constructFieldsForAuditValidation.setCURR_VERSION("");
1037 constructFieldsForAuditValidation.setCURR_STATE("");
1038 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1041 @Test // (enabled = false)
1042 public void createProductDuplicateTagRemoved() throws Exception {
1043 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1044 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1045 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), productReqDetails.getName()));
1046 normalizedName = productReqDetails.getName().toLowerCase();
1047 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1048 ProductRestUtils.checkCreateResponse(createProduct);
1049 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1050 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1051 compareExpectedAndActualProducts(productReqDetails, createProduct);
1052 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1053 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1054 productManager1.getUserId());
1055 ProductRestUtils.checkSuccess(getProductRes);
1056 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1057 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1058 ComponentOperationEnum.GET_COMPONENT);
1059 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1060 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1061 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1062 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1063 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1066 @Test // (enabled = false)
1067 public void createProductContactsIsEmpty() throws Exception {
1068 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1069 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1070 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1071 normalizedName = productReqDetails.getName().toLowerCase();
1072 productReqDetails.setContacts(Arrays.asList(""));
1073 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1074 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1075 createProduct.getErrorCode().intValue());
1076 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1077 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1078 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_CONTACT,
1079 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1080 constructFieldsForAuditValidation.setCURR_VERSION("");
1081 constructFieldsForAuditValidation.setCURR_STATE("");
1082 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1085 @Test // (enabled = false)
1086 public void createProductContactsInvalidFormat() throws Exception {
1087 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1088 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1089 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1090 normalizedName = productReqDetails.getName().toLowerCase();
1091 productReqDetails.setContacts(Arrays.asList("bt750345"));
1092 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1093 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1094 createProduct.getErrorCode().intValue());
1095 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1096 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1097 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_CONTACT,
1098 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1099 constructFieldsForAuditValidation.setCURR_VERSION("");
1100 constructFieldsForAuditValidation.setCURR_STATE("");
1101 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1104 @Test // (enabled = false)
1105 public void createProductConvertContactsToLowerCase() throws Exception {
1106 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1107 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1108 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1109 normalizedName = productReqDetails.getName().toLowerCase();
1110 productReqDetails.setContacts(Arrays.asList(productManager1.getUserId().toUpperCase()));
1111 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1112 ProductRestUtils.checkCreateResponse(createProduct);
1113 productReqDetails.setContacts(Arrays.asList(productManager1.getUserId().toLowerCase()));
1114 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1115 compareExpectedAndActualProducts(productReqDetails, createProduct);
1116 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1117 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1118 productManager1.getUserId());
1119 ProductRestUtils.checkSuccess(getProductRes);
1120 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1121 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1122 ComponentOperationEnum.GET_COMPONENT);
1123 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1124 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1125 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1126 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1127 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1130 @Test // (enabled = false)
1131 public void createProductContactsDoexNotContainTheProductCreator() throws Exception {
1132 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1133 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1134 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1135 normalizedName = productReqDetails.getName().toLowerCase();
1136 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId()));
1137 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1138 ProductRestUtils.checkCreateResponse(createProduct);
1139 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId(), productManager1.getUserId()));
1140 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1141 compareExpectedAndActualProducts(productReqDetails, createProduct);
1142 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1143 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1144 productManager1.getUserId());
1145 ProductRestUtils.checkSuccess(getProductRes);
1146 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1147 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1148 ComponentOperationEnum.GET_COMPONENT);
1149 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1150 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1151 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1152 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1155 @Test // (enabled = false)
1156 public void createProductContactsNotAllowedAsdcUsers() throws Exception {
1157 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1158 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1159 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1160 normalizedName = productReqDetails.getName().toLowerCase();
1161 productReqDetails.setContacts(Arrays.asList(designerUser.getUserId()));
1162 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1163 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1164 createProduct.getErrorCode().intValue());
1165 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1166 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1167 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PRODUCT_CONTACT,
1168 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING,
1169 designerUser.getUserId());
1170 constructFieldsForAuditValidation.setCURR_VERSION("");
1171 constructFieldsForAuditValidation.setCURR_STATE("");
1172 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1175 @Test // (enabled = false)
1176 public void createProductContactsNotAsdcUser() throws Exception {
1177 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1178 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1179 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1180 normalizedName = productReqDetails.getName().toLowerCase();
1181 String nonAsdcUser = "bh1234";
1182 productReqDetails.setContacts(Arrays.asList(nonAsdcUser));
1183 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1184 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1185 createProduct.getErrorCode().intValue());
1186 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1187 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1188 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PRODUCT_CONTACT,
1189 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, nonAsdcUser);
1190 constructFieldsForAuditValidation.setCURR_VERSION("");
1191 constructFieldsForAuditValidation.setCURR_STATE("");
1192 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1195 @Test // (enabled = false)
1196 public void createProductProjectCodeIsEmpty() throws Exception {
1197 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1198 // productReqDetails.setName("CIProduct1");
1199 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1200 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1201 productReqDetails.setProjectCode("");
1202 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1203 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1204 createProduct.getErrorCode().intValue());
1205 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1206 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1207 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_PROJECT_CODE,
1208 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1209 constructFieldsForAuditValidation.setCURR_VERSION("");
1210 constructFieldsForAuditValidation.setCURR_STATE("");
1211 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1214 @Test // (enabled = false)
1215 public void createProductProjectCodeIsNull() throws Exception {
1216 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1217 // productReqDetails.setName("CIProduct1");
1218 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1219 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1220 productReqDetails.setProjectCode(null);
1221 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1222 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1223 createProduct.getErrorCode().intValue());
1224 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1225 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1226 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_PROJECT_CODE,
1227 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1228 constructFieldsForAuditValidation.setCURR_VERSION("");
1229 constructFieldsForAuditValidation.setCURR_STATE("");
1230 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1233 @Test // (enabled = false)
1234 public void createProductProjectCodeIsNotNumeric() throws Exception {
1235 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1236 // productReqDetails.setName("CIProduct1");
1237 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1238 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1239 productReqDetails.setProjectCode("asdfgh");
1240 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1241 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1242 createProduct.getErrorCode().intValue());
1243 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1244 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1245 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1246 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1247 constructFieldsForAuditValidation.setCURR_VERSION("");
1248 constructFieldsForAuditValidation.setCURR_STATE("");
1249 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1252 @Test // (enabled = false)
1253 public void createProductProjectCodeHasnMinCharacters() throws Exception {
1255 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1256 // productReqDetails.setName("CIProduct1");
1257 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1258 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1259 productReqDetails.setProjectCode("12345");
1260 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1261 ProductRestUtils.checkCreateResponse(createProduct);
1262 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1263 compareExpectedAndActualProducts(productReqDetails, createProduct);
1264 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1265 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1266 productManager1.getUserId());
1267 ProductRestUtils.checkSuccess(getProductRes);
1268 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1269 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1270 ComponentOperationEnum.GET_COMPONENT);
1271 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1272 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1273 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1274 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1277 @Test // (enabled = false)
1278 public void createProductProjectCodeHasnMaxCharacters() throws Exception {
1280 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1281 // productReqDetails.setName("CIProduct1");
1282 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1283 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1284 productReqDetails.setProjectCode("1234567890");
1285 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1286 ProductRestUtils.checkCreateResponse(createProduct);
1287 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1288 compareExpectedAndActualProducts(productReqDetails, createProduct);
1289 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1290 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1291 productManager1.getUserId());
1292 ProductRestUtils.checkSuccess(getProductRes);
1293 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1294 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1295 ComponentOperationEnum.GET_COMPONENT);
1296 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1297 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1298 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1299 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1302 @Test // (enabled = false)
1303 public void createProductProjectCodeExceedMaxCharacters() throws Exception {
1305 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1306 // productReqDetails.setName("CIProduct1");
1307 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1308 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1309 productReqDetails.setProjectCode("12345678901");
1310 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1311 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1312 createProduct.getErrorCode().intValue());
1313 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1314 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1315 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1316 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1317 constructFieldsForAuditValidation.setCURR_VERSION("");
1318 constructFieldsForAuditValidation.setCURR_STATE("");
1319 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1322 @Test // (enabled = false)
1323 public void createProductProjectCodeLessThanMinCharacters() throws Exception {
1325 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1326 // productReqDetails.setName("CIProduct1");
1327 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1328 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1329 productReqDetails.setProjectCode("1234");
1330 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1331 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1332 createProduct.getErrorCode().intValue());
1333 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1334 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1335 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1336 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1337 constructFieldsForAuditValidation.setCURR_VERSION("");
1338 constructFieldsForAuditValidation.setCURR_STATE("");
1339 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1342 @Test // (enabled = false)
1343 public void createProductIconIsEmpty() throws Exception {
1344 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1345 // productReqDetails.setName("CIProduct1");
1346 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1347 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1348 productReqDetails.setIcon("");
1349 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1350 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1351 createProduct.getErrorCode().intValue());
1352 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1353 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1354 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_ICON,
1355 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1356 constructFieldsForAuditValidation.setCURR_VERSION("");
1357 constructFieldsForAuditValidation.setCURR_STATE("");
1358 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1361 @Test // (enabled = false)
1362 public void createProductIconIsNull() throws Exception {
1363 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1364 // productReqDetails.setName("CIProduct1");
1365 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1366 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1367 productReqDetails.setIcon(null);
1368 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1369 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1370 createProduct.getErrorCode().intValue());
1371 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1372 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1373 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_ICON,
1374 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1375 constructFieldsForAuditValidation.setCURR_VERSION("");
1376 constructFieldsForAuditValidation.setCURR_STATE("");
1377 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1380 @Test // (enabled = false)
1381 public void createProductIconMaxLength() throws Exception {
1382 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1383 // productReqDetails.setName("CIProduct1");
1384 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1385 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1386 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbfv");
1387 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1388 ProductRestUtils.checkCreateResponse(createProduct);
1389 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1390 compareExpectedAndActualProducts(productReqDetails, createProduct);
1391 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1392 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1393 productManager1.getUserId());
1394 ProductRestUtils.checkSuccess(getProductRes);
1395 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1396 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1397 ComponentOperationEnum.GET_COMPONENT);
1398 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1399 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1400 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1401 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1404 @Test // (enabled = false)
1405 public void createProductIconExceedMaxLength() throws Exception {
1406 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1407 // productReqDetails.setName("CIProduct1");
1408 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1409 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1410 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbf12");
1411 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1412 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1413 createProduct.getErrorCode().intValue());
1414 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1415 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1416 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT,
1417 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "25");
1418 constructFieldsForAuditValidation.setCURR_VERSION("");
1419 constructFieldsForAuditValidation.setCURR_STATE("");
1420 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1423 @Test // (enabled = false)
1424 public void createProductIconAllowedCharacters() throws Exception {
1425 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1426 // productReqDetails.setName("CIProduct1");
1427 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1428 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1429 productReqDetails.setIcon("a--s-fghjk_q__r1234567890");
1430 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1431 ProductRestUtils.checkCreateResponse(createProduct);
1432 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1433 compareExpectedAndActualProducts(productReqDetails, createProduct);
1434 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1435 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1436 productManager1.getUserId());
1437 ProductRestUtils.checkSuccess(getProductRes);
1438 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1439 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1440 ComponentOperationEnum.GET_COMPONENT);
1441 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1442 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1443 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1444 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1447 @Test (enabled = false)
1448 public void createProductIconInValidCharacters() throws Exception {
1449 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1450 // productReqDetails.setName("CIProduct1");
1451 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1452 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1453 String icon = "asdfg";
1454 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
1456 RestResponse createProduct;
1457 for (int i = 0; i < invalidChars.length; i++) {
1458 productReqDetails.setIcon(icon + invalidChars[i]);
1459 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1460 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1461 createProduct.getErrorCode().intValue());
1462 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "",
1464 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1465 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_ICON,
1466 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1467 constructFieldsForAuditValidation.setCURR_VERSION("");
1468 constructFieldsForAuditValidation.setCURR_STATE("");
1469 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1473 @Test // (enabled = false)
1474 public void createProductIsActiveisEmpty() throws Exception {
1475 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1476 // productReqDetails.setName("CIProduct1");
1477 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1478 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1479 productReqDetails.setActive("");
1480 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1481 ProductRestUtils.checkCreateResponse(createProduct);
1482 productReqDetails.setActive("false");
1483 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1484 compareExpectedAndActualProducts(productReqDetails, createProduct);
1485 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1486 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1487 productManager1.getUserId());
1488 ProductRestUtils.checkSuccess(getProductRes);
1489 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1490 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1491 ComponentOperationEnum.GET_COMPONENT);
1492 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1493 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1494 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1495 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1498 @Test // (enabled = false)
1499 public void createProductIsActiveisNull() throws Exception {
1500 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1501 // productReqDetails.setName("CIProduct1");
1502 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1503 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1504 productReqDetails.setActive("");
1505 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1506 ProductRestUtils.checkCreateResponse(createProduct);
1507 productReqDetails.setActive("false");
1508 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1509 compareExpectedAndActualProducts(productReqDetails, createProduct);
1510 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1511 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1512 productManager1.getUserId());
1513 ProductRestUtils.checkSuccess(getProductRes);
1514 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1515 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1516 ComponentOperationEnum.GET_COMPONENT);
1517 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1518 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1519 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1520 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1521 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1524 @Test // (enabled = false)
1525 public void createProductIsActiveisFalse() throws Exception {
1526 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1527 // productReqDetails.setName("CIProduct1");
1528 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1529 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1530 productReqDetails.setActive("false");
1531 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1532 ProductRestUtils.checkCreateResponse(createProduct);
1533 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1534 compareExpectedAndActualProducts(productReqDetails, createProduct);
1535 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1536 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1537 productManager1.getUserId());
1538 ProductRestUtils.checkSuccess(getProductRes);
1539 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1540 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1541 ComponentOperationEnum.GET_COMPONENT);
1542 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1543 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1544 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1545 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1549 public void createProductIsActiveisHasInvalidValue() throws Exception {
1550 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1551 // productReqDetails.setName("CIProduct1");
1552 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1553 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1554 productReqDetails.setActive("xfalse");
1555 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1556 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1557 createProduct.getErrorCode().intValue());
1558 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1559 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1560 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_CONTENT,
1561 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1562 constructFieldsForAuditValidation.setCURR_VERSION("");
1563 constructFieldsForAuditValidation.setCURR_STATE("");
1564 constructFieldsForAuditValidation.setRESOURCE_NAME("");
1565 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1568 @Test // (enabled = false)
1569 public void createProductIsActiveisTrue() throws Exception {
1570 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1571 // productReqDetails.setName("CIProduct1");
1572 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1573 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1574 productReqDetails.setActive("true");
1575 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1576 ProductRestUtils.checkCreateResponse(createProduct);
1577 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1578 compareExpectedAndActualProducts(productReqDetails, createProduct);
1579 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1580 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1581 productManager1.getUserId());
1582 ProductRestUtils.checkSuccess(getProductRes);
1583 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1584 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1585 ComponentOperationEnum.GET_COMPONENT);
1586 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1587 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1588 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1589 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1592 //////////////////////////////////////////////
1594 @Test // (enabled = false)
1595 public void createProductNameValidationNormalizationNameWithSpaces() throws Exception {
1596 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1597 // productReqDetails.setName("Abba Emma");
1598 // productReqDetails.setName("abba emma");
1599 // productReqDetails.setTags(Arrays.asList("abba emma"));
1600 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1601 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1602 ProductRestUtils.checkCreateResponse(createProduct);
1603 String actualNormalizedNameFromResponse = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
1605 assertTrue(actualNormalizedNameFromResponse.equals(normalizedName));
1606 // productReqDetails.setName("Abba Emma");
1607 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1608 compareExpectedAndActualProducts(productReqDetails, createProduct);
1609 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1610 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1611 productManager1.getUserId());
1612 ProductRestUtils.checkSuccess(getProductRes);
1613 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1614 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1615 ComponentOperationEnum.GET_COMPONENT);
1616 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1617 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1618 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1619 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1620 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1623 private void compareExpectedAndActualProducts(ProductReqDetails productReqDetails, RestResponse createProduct)
1624 throws JSONException {
1625 String productName = ResponseParser.getNameFromResponse(createProduct);
1626 assertTrue(productReqDetails.getName().equals(productName));
1627 String productIcon = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "icon");
1628 assertTrue(productReqDetails.getIcon().equals(productIcon));
1629 String productFullName = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "fullName");
1630 assertTrue(productReqDetails.getFullName().equals(productFullName));
1631 String productProjectCode = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "projectCode");
1632 assertTrue(productReqDetails.getProjectCode().equals(productProjectCode));
1633 String productIsActive = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "isActive");
1634 String expectedIsActive = (productReqDetails.getActive() != null ? productReqDetails.getActive() : "false");
1635 assertTrue(productIsActive.equals(expectedIsActive));
1636 String productdescription = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "description");
1637 assertTrue(productReqDetails.getDescription().equals(productdescription));
1638 String productNormalizedName = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
1640 assertTrue(normalizedName.equals(productNormalizedName));
1641 String productContacts = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "contacts");
1642 JSONArray reciviedContacts = new JSONArray(productContacts);
1643 String actualContact = null;
1644 for (int i = 0; i < reciviedContacts.length(); i++) {
1645 actualContact = reciviedContacts.getString(i);
1646 assertEquals(productReqDetails.getContacts().get(i), actualContact);
1648 String productTags = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "tags");
1649 JSONArray reciviedTages = new JSONArray(productTags);
1650 String actualTag = null;
1651 for (int i = 0; i < reciviedTages.length(); i++) {
1652 actualTag = reciviedTages.getString(i);
1653 assertEquals(productReqDetails.getTags().get(i), actualTag);
1658 ///////////////////////////////////////////////////////
1660 public void createProductSuccessFlow() throws Exception {
1661 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1662 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1663 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
1664 createProduct.getErrorCode().intValue());
1666 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1667 productManager1.getUserId());
1668 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
1669 getProductRes.getErrorCode().intValue());
1671 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1672 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1673 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1674 ComponentOperationEnum.GET_COMPONENT);
1675 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1679 public void createProductSetIsActive() throws Exception {
1680 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1681 productReqDetails.setActive("true");
1682 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1683 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
1684 createProduct.getErrorCode().intValue());
1686 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1687 productManager1.getUserId());
1688 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
1689 getProductRes.getErrorCode().intValue());
1691 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1692 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1693 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1694 ComponentOperationEnum.GET_COMPONENT);
1695 assertEquals(actualProduct.getIsActive(), new Boolean(true));
1699 public void createProductNoIcon() throws Exception {
1700 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1701 productReqDetails.setIcon(null);
1702 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1703 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_DATA,
1704 createProduct.getErrorCode().intValue());
1709 public void createProductNoProjectCode() throws Exception {
1710 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1711 productReqDetails.setProjectCode(null);
1712 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1713 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_DATA,
1714 createProduct.getErrorCode().intValue());