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