gerrit.onap Code Review - sdc.git/blob

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