test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/resource/GetAllResourceVersions.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.resource;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertTrue;
  25
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29
  30 import org.apache.log4j.lf5.util.ResourceUtils;
  31 import org.junit.rules.TestName;
  32 import org.openecomp.sdc.be.model.Resource;
  33 import org.openecomp.sdc.be.model.User;
  34 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  35 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  36 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  37 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  38 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  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.ElementFactory;
  43 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  44 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  45 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48 import org.testng.AssertJUnit;
  49 import org.testng.annotations.AfterMethod;
  50 import org.testng.annotations.BeforeMethod;
  51 import org.testng.annotations.Test;
  52
  53 public class GetAllResourceVersions extends ComponentBaseTest {
  54
  55         private static Logger logger = LoggerFactory.getLogger(GetAllResourceVersions.class.getName());
  56         protected User designerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  57         protected User adminModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  58
  59         protected ResourceReqDetails resourceDetails;
  60
  61         public static TestName name = new TestName();
  62
  63         public GetAllResourceVersions() {
  64                 super(name, GetAllResourceVersions.class.getName());
  65
  66         }
  67
  68         //// NEW
  69
  70         protected void deleteAllVersionOfResource() throws Exception {
  71                 RestResponse response = null;
  72
  73                 String[] versions = { "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "2.0",
  74                                 "2.1", "2.2", "2.3", "2.4", "2.5", "3.0", "4.0", "4.1" };
  75
  76                 for (String version : versions) {
  77
  78                         response = ResourceRestUtils.deleteResourceByNameAndVersion(designerDetails,
  79                                         resourceDetails.getName().toUpperCase(), version);
  80                         AssertJUnit.assertTrue("delete request returned status:" + response.getErrorCode(),
  81                                         response.getErrorCode() == 204 || response.getErrorCode() == 404);
  82
  83                         response = ResourceRestUtils.deleteResourceByNameAndVersion(designerDetails, resourceDetails.getName(),
  84                                         version);
  85                         AssertJUnit.assertTrue("delete request returned status:" + response.getErrorCode(),
  86                                         response.getErrorCode() == 204 || response.getErrorCode() == 404);
  87
  88                 }
  89         }
  90
  91         @BeforeMethod
  92         public void init() throws Exception {
  93                 resourceDetails = defineResourse();
  94                 deleteAllVersionOfResource();
  95
  96         }
  97
  98         @AfterMethod
  99         public void endOfTests() throws Exception {
 100                 deleteAllVersionOfResource();
 101         }
 102
 103         protected ResourceReqDetails defineResourse() {
 104                 String resourceName = "cisco4";
 105                 String description = "description";
 106                 ArrayList<String> resourceTags = new ArrayList<String>();
 107                 resourceTags.add(resourceName);
 108                 // String category = ServiceCategoriesEnum.MOBILITY.getValue();
 109                 ArrayList<String> derivedFrom = new ArrayList<String>();
 110                 derivedFrom.add("tosca.nodes.Root");
 111                 String vendorName = "Oracle";
 112                 String vendorRelease = "1.5";
 113                 String contactId = "jh0003";
 114                 String icon = "myICON";
 115
 116                 ResourceReqDetails resourceDetails = new ResourceReqDetails(resourceName, description, resourceTags, null,
 117                                 derivedFrom, vendorName, vendorRelease, contactId, icon);
 118                 resourceDetails.addCategoryChain(ResourceCategoryEnum.GENERIC_INFRASTRUCTURE.getCategory(),
 119                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE.getSubCategory());
 120
 121                 return resourceDetails;
 122         }
 123
 124         @Test
 125         public void getResourceAllVersions_version15() throws Exception {
 126                 // create resource
 127                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 128                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 129                 AssertJUnit.assertTrue("create request returned status:" + restResponse.getErrorCode(),
 130                                 restResponse.getErrorCode() == 201);
 131                 String resourceName = resourceDetails.getName();
 132                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 133                 // restResponse);
 134
 135                 // change resource version to 0.5
 136                 RestResponse checkoutResource;
 137                 for (int x = 0; x < 4; x++) {
 138                         logger.debug("Changing resource life cycle ");
 139                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 140                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 141                         AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 142                                         checkoutResource.getErrorCode().intValue());
 143
 144                         logger.debug("Changing resource life cycle ");
 145                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 146                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 147                         AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 148                                         checkoutResource.getErrorCode().intValue());
 149                 }
 150
 151                 logger.debug("Changing resource life cycle ");
 152                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 153                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 154                 AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 155                                 checkoutResource.getErrorCode().intValue());
 156                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 157                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 158                 AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 159                                 checkoutResource.getErrorCode().intValue());
 160                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 161                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 162                 AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 163                                 checkoutResource.getErrorCode().intValue());
 164                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 165                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 166                 AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 167                                 checkoutResource.getErrorCode().intValue());
 168                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 169                 // change resource version to 1.5
 170                 for (int x = 0; x < 5; x++) {
 171                         logger.debug("Changing resource life cycle ");
 172                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 173                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 174                         origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 175                         AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 176                                         checkoutResource.getErrorCode().intValue());
 177                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 178                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 179                         AssertJUnit.assertEquals("Check response code after checkout resource", 200,
 180                                         checkoutResource.getErrorCode().intValue());
 181                 }
 182
 183                 // validate get response
 184                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 185                                 resourceDetails.getUniqueId());
 186                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 187                 Map<String, String> getVersionsMap = res.getAllVersions();
 188                 AssertJUnit.assertTrue(origVersionsMap.equals(getVersionsMap));
 189
 190         }
 191
 192         protected RestResponse createResource(User sdncModifierDetails, ResourceReqDetails resourceDetails)
 193                         throws Exception {
 194                 // clean ES DB
 195                 DbUtils.cleanAllAudits();
 196
 197                 // create resource
 198                 RestResponse restResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 199
 200                 // validate response
 201                 AssertJUnit.assertNotNull("check response object is not null after create resource", restResponse);
 202                 AssertJUnit.assertNotNull("check error code exists in response after create resource",
 203                                 restResponse.getErrorCode());
 204                 AssertJUnit.assertEquals("Check response code after create resource", 201,
 205                                 restResponse.getErrorCode().intValue());
 206
 207                 return restResponse;
 208         }
 209
 210         @Test
 211         public void getResourceAllVersions_version05() throws Exception {
 212
 213                 // create resource
 214                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 215                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 216                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 217                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 218                 // restResponse);
 219                 // change resource version to 0.5
 220                 RestResponse checkoutResource;
 221
 222                 logger.debug("Changing resource life cycle ");
 223                 for (int x = 0; x < 4; x++) {
 224                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 225                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 226                         assertEquals("Check response code after checkout resource", 200,
 227                                         checkoutResource.getErrorCode().intValue());
 228                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 229                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 230                         assertEquals("Check response code after checkout resource", 200,
 231                                         checkoutResource.getErrorCode().intValue());
 232                         origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 233                 }
 234                 // validate get response
 235                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 236                                 resourceDetails.getUniqueId());
 237                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 238                 Map<String, String> getVersionsMap = res.getAllVersions();
 239                 assertTrue(origVersionsMap.equals(getVersionsMap));
 240
 241         }
 242
 243         @Test
 244         public void getResourceAllVersions_version01() throws Exception {
 245                 // create resource
 246                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 247                 String resourceName = resourceDetails.getName();
 248
 249                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 250                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 251
 252                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 253                 // restResponse);
 254
 255                 // validate get response
 256                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 257                                 resourceDetails.getUniqueId());
 258                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 259                 Map<String, String> getVersionsMap = res.getAllVersions();
 260                 assertTrue(origVersionsMap.equals(getVersionsMap));
 261
 262         }
 263
 264         @Test
 265         public void getResourceAllVersions_version25() throws Exception {
 266
 267                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 268
 269                 // create resource
 270                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 271                 assertTrue("create request returned status:" + restResponse.getErrorCode(), restResponse.getErrorCode() == 201);
 272                 String resourceName = resourceDetails.getName();
 273                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 274                 // restResponse);
 275
 276                 // change resource version to 0.5
 277                 RestResponse checkoutResource;
 278                 for (int x = 0; x < 4; x++) {
 279                         logger.debug("Changing resource life cycle ");
 280                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 281                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 282                         assertEquals("Check response code after checkout resource", 200,
 283                                         checkoutResource.getErrorCode().intValue());
 284
 285                         logger.debug("Changing resource life cycle ");
 286                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 287                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 288                         assertEquals("Check response code after checkout resource", 200,
 289                                         checkoutResource.getErrorCode().intValue());
 290                 }
 291
 292                 // resource version 1.0
 293                 logger.debug("Changing resource life cycle ");
 294                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 295                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 296                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 297                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 298                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 299                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 300                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 301                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 302                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 303                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 304                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 305                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 306                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 307
 308                 // change resource version to 1.5
 309                 for (int x = 0; x < 5; x++) {
 310                         logger.debug("Changing resource life cycle ");
 311                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 312                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 313                         assertEquals("Check response code after checkout resource", 200,
 314                                         checkoutResource.getErrorCode().intValue());
 315                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 316                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 317                         assertEquals("Check response code after checkout resource", 200,
 318                                         checkoutResource.getErrorCode().intValue());
 319                 }
 320
 321                 // resource version 2.0
 322                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 323                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 324                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 325                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 326                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 327                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 328                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 329                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 330                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 331                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 332
 333                 // change resource version to 2.5
 334                 for (int x = 0; x < 5; x++) {
 335                         logger.debug("Changing resource life cycle ");
 336                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 337                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 338                         assertEquals("Check response code after checkout resource", 200,
 339                                         checkoutResource.getErrorCode().intValue());
 340                         origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 341
 342                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 343                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 344                         assertEquals("Check response code after checkout resource", 200,
 345                                         checkoutResource.getErrorCode().intValue());
 346                 }
 347
 348                 // validate get response
 349                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 350                                 resourceDetails.getUniqueId());
 351                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 352                 Map<String, String> getVersionsMap = res.getAllVersions();
 353                 assertTrue(origVersionsMap.equals(getVersionsMap));
 354
 355         }
 356
 357         @Test
 358         public void getResourceAllVersions_ReadyForCertification_version05() throws Exception {
 359                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 360                 // create resource
 361                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 362                 assertTrue("create request returned status:" + restResponse.getErrorCode(), restResponse.getErrorCode() == 201);
 363                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 364                 String resourceName = resourceDetails.getName();
 365                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 366                 // restResponse);
 367
 368                 // change resource version to 0.5
 369                 RestResponse checkoutResource;
 370                 for (int x = 0; x < 4; x++) {
 371                         logger.debug("Changing resource life cycle ");
 372                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 373                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 374                         assertEquals("Check response code after checkout resource", 200,
 375                                         checkoutResource.getErrorCode().intValue());
 376
 377                         logger.debug("Changing resource life cycle ");
 378                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 379                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 380                         assertEquals("Check response code after checkout resource", 200,
 381                                         checkoutResource.getErrorCode().intValue());
 382                         origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 383                 }
 384
 385                 logger.debug("Changing resource life cycle ");
 386                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 387                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 388                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 389                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 390                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 391                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 392
 393                 // validate get response
 394                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 395                                 resourceDetails.getUniqueId());
 396                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 397                 Map<String, String> getVersionsMap = res.getAllVersions();
 398                 assertTrue(origVersionsMap.equals(getVersionsMap));
 399
 400         }
 401
 402         @Test
 403         public void getResourceAllVersions_CertifactionInProgress_version05() throws Exception {
 404                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 405                 // create resource
 406                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 407                 assertTrue("create request returned status:" + restResponse.getErrorCode(), restResponse.getErrorCode() == 201);
 408                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 409
 410                 String resourceName = resourceDetails.getName();
 411                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 412                 // restResponse);
 413
 414                 // change resource version to 0.5
 415                 RestResponse checkoutResource;
 416                 for (int x = 0; x < 4; x++) {
 417                         logger.debug("Changing resource life cycle ");
 418                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 419                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 420                         assertEquals("Check response code after checkout resource", 200,
 421                                         checkoutResource.getErrorCode().intValue());
 422
 423                         logger.debug("Changing resource life cycle ");
 424                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 425                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 426                         assertEquals("Check response code after checkout resource", 200,
 427                                         checkoutResource.getErrorCode().intValue());
 428                         origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 429                 }
 430
 431                 logger.debug("Changing resource life cycle ");
 432                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 433                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 434                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 435                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 436                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 437                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 438                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 439                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 440                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 441
 442                 // validate get response
 443                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 444                                 resourceDetails.getUniqueId());
 445                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 446                 Map<String, String> getVersionsMap = res.getAllVersions();
 447                 assertTrue(origVersionsMap.equals(getVersionsMap));
 448
 449         }
 450
 451         @Test
 452         public void getResourceAllVersions_Certified_version10() throws Exception {
 453
 454                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 455
 456                 // create resource
 457                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 458                 assertTrue("create request returned status:" + restResponse.getErrorCode(), restResponse.getErrorCode() == 201);
 459                 String resourceName = resourceDetails.getName();
 460                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 461                 // restResponse);
 462
 463                 // change resource version to 0.5
 464                 RestResponse checkoutResource;
 465                 for (int x = 0; x < 4; x++) {
 466                         logger.debug("Changing resource life cycle ");
 467                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 468                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 469                         assertEquals("Check response code after checkout resource", 200,
 470                                         checkoutResource.getErrorCode().intValue());
 471                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 472                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 473                         assertEquals("Check response code after checkout resource", 200,
 474                                         checkoutResource.getErrorCode().intValue());
 475
 476                 }
 477                 logger.debug("Changing resource life cycle ");
 478                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 479                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 480                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 481                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 482                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 483                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 484                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 485                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 486                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 487                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 488                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 489                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 490                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 491                 // validate get response
 492                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 493                                 resourceDetails.getUniqueId());
 494                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 495                 Map<String, String> getVersionsMap = res.getAllVersions();
 496                 assertTrue(origVersionsMap.equals(getVersionsMap));
 497
 498         }
 499
 500         @Test
 501         public void getResourceAllVersions_Certified_version20() throws Exception {
 502
 503                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 504
 505                 // create resource
 506                 RestResponse restResponse = createResource(designerDetails, resourceDetails);
 507                 assertTrue("create request returned status:" + restResponse.getErrorCode(), restResponse.getErrorCode() == 201);
 508                 String resourceName = resourceDetails.getName();
 509                 // resourceUtils.addResourceMandatoryArtifacts(designerDetails,
 510                 // restResponse);
 511
 512                 // change resource version to 0.5
 513                 RestResponse checkoutResource;
 514                 for (int x = 0; x < 4; x++) {
 515                         logger.debug("Changing resource life cycle ");
 516                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 517                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 518                         assertEquals("Check response code after checkout resource", 200,
 519                                         checkoutResource.getErrorCode().intValue());
 520                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 521                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 522                         assertEquals("Check response code after checkout resource", 200,
 523                                         checkoutResource.getErrorCode().intValue());
 524                 }
 525
 526                 // get to version 1.0
 527                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 528                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 529                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 530                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 531                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 532                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 533                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 534                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 535                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 536                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 537                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 538                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 539                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 540
 541                 // change resource version to 1.5
 542                 for (int x = 0; x < 4; x++) {
 543                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 544                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 545                         assertEquals("Check response code after checkout resource", 200,
 546                                         checkoutResource.getErrorCode().intValue());
 547                         checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, designerDetails,
 548                                         resourceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 549                         assertEquals("Check response code after checkout resource", 200,
 550                                         checkoutResource.getErrorCode().intValue());
 551                 }
 552
 553                 // get to version 1.0
 554                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 555                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 556                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 557                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 558                                 resourceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 559                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 560                 checkoutResource = LifecycleRestUtils.changeResourceState(resourceDetails, adminModifierDetails,
 561                                 resourceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
 562                 assertEquals("Check response code after checkout resource", 200, checkoutResource.getErrorCode().intValue());
 563                 origVersionsMap.put(resourceDetails.getVersion(), resourceDetails.getUniqueId());
 564
 565                 // validate get response
 566                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails,
 567                                 resourceDetails.getUniqueId());
 568                 Resource res = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 569                 Map<String, String> getVersionsMap = res.getAllVersions();
 570                 assertTrue(origVersionsMap.equals(getVersionsMap));
 571
 572         }
 573
 574         @Test
 575         public void getResourceAllVersions_ResourceNotFound() throws Exception {
 576
 577                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(designerDetails, "123456789");
 578                 assertEquals("Check response code after checkout resource", 404, resourceGetResponse.getErrorCode().intValue());
 579
 580         }
 581
 582 }