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.service;
  22
  23 import org.junit.Rule;
  24 import org.junit.rules.TestName;
  25 import org.openecomp.sdc.be.dao.api.ActionStatus;
  26 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  27 import org.openecomp.sdc.be.model.Component;
  28 import org.openecomp.sdc.be.model.Service;
  29 import org.openecomp.sdc.be.model.User;
  30 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  31 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  32 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  33 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  34 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  35 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  36 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  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.execute.lifecycle.LCSbaseTest;
  40 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  41 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  42 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  43 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  44 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  45 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  46 import org.testng.annotations.BeforeMethod;
  47 import org.testng.annotations.Test;
  48
  49 import java.util.Arrays;
  50 import java.util.HashMap;
  51 import java.util.List;
  52 import java.util.Map;
  53
  54 import static org.testng.AssertJUnit.assertEquals;
  55 import static org.testng.AssertJUnit.assertTrue;
  56
  57 public class GetAllServiceVersions extends ComponentBaseTest {
  58         protected ResourceReqDetails resourceDetails;
  59         protected ServiceReqDetails serviceDetails;
  60         protected User sdncDesignerDetails;
  61         protected User sdncDesignerDetails2;
  62         protected User sdncAdminDetails;
  63         protected User sdncGovernorDeatails;
  64         protected User sdncTesterDetails;
  65         protected User sdncOpsDetails;
  66         protected ComponentInstanceReqDetails resourceInstanceReqDetails;
  67         protected Component resourceDetailsVFCcomp;
  68         protected Service serviceServ;
  69
  70         @Rule
  71         public static TestName name = new TestName();
  72
  73         @BeforeMethod
  74         public void setUp() throws Exception {
  75
  76                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  77                 sdncDesignerDetails2 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2);
  78                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  79                 sdncGovernorDeatails = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  80                 sdncTesterDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  81                 sdncOpsDetails = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
  82                 resourceDetailsVFCcomp = AtomicOperationUtils
  83                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
  84                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.HEAT, resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
  85                                 true, true);
  86
  87                 AtomicOperationUtils.changeComponentState(resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
  88                                 LifeCycleStatesEnum.CERTIFY, true);
  89                 serviceServ = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
  90                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceDetailsVFCcomp, serviceServ,
  91                                 UserRoleEnum.DESIGNER, true);
  92
  93                 serviceDetails = new ServiceReqDetails(serviceServ);
  94
  95         }
  96
  97         @Test
  98         public void GetAllServiceVersions_Version05() throws Exception {
  99
 100                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 101                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 102                 for (int x = 0; x < 4; x++) {
 103                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 104                                         LifeCycleStatesEnum.CHECKIN);
 105                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 106                                         LifeCycleStatesEnum.CHECKOUT);
 107                         origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 108
 109                 }
 110                 // validate get response
 111                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 112                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 113                 Map<String, String> getVersionsMap = res.getAllVersions();
 114                 assertTrue(origVersionsMap.equals(getVersionsMap));
 115
 116         }
 117
 118         @Test
 119         public void GetAllServiceVersions_Version01() throws Exception {
 120
 121                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 122                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 123
 124                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 125                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 126                 Map<String, String> getVersionsMap = res.getAllVersions();
 127                 assertTrue(origVersionsMap.equals(getVersionsMap));
 128         }
 129
 130         @Test
 131         public void GetAllServiceVersions_Version15() throws Exception {
 132                 // addMandatoryArtifactsToService();
 133                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 134                 for (int x = 0; x < 4; x++) {
 135                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 136                                         LifeCycleStatesEnum.CHECKIN);
 137                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 138                                         LifeCycleStatesEnum.CHECKOUT);
 139                 }
 140
 141                 RestResponse changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 142                 // serviceServ.setUniqueId(serviceDetails.getUniqueId());
 143                 // RestResponse changeServiceState =
 144                 // AtomicOperationUtils.changeComponentState(serviceServ,
 145                 // UserRoleEnum.ADMIN, LifeCycleStatesEnum.CERTIFY, false).getRight();
 146
 147                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 148                                 changeServiceState.getErrorCode() == 200);
 149                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 150
 151                 for (int x = 0; x < 5; x++) {
 152                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 153                                         LifeCycleStatesEnum.CHECKOUT);
 154                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 155                                         LifeCycleStatesEnum.CHECKIN);
 156                         origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 157
 158                 }
 159
 160                 // validate get response
 161                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 162                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 163                 Map<String, String> getVersionsMap = res.getAllVersions();
 164                 assertTrue(origVersionsMap.equals(getVersionsMap));
 165         }
 166
 167         @Test
 168         public void GetAllServiceVersions_Version25() throws Exception {
 169                 // addMandatoryArtifactsToService();
 170                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 171                 for (int x = 0; x < 4; x++) {
 172                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 173                                         LifeCycleStatesEnum.CHECKIN);
 174                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 175                                         LifeCycleStatesEnum.CHECKOUT);
 176                 }
 177
 178                 // getting to version 1.0
 179                 RestResponse changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 180                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 181                                 changeServiceState.getErrorCode() == 200);
 182                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 183
 184                 // getting to version 1.5
 185                 for (int x = 0; x < 5; x++) {
 186                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 187                                         LifeCycleStatesEnum.CHECKIN);
 188                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 189                                         LifeCycleStatesEnum.CHECKOUT);
 190                 }
 191
 192                 // getting to version 2.0
 193                 changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 194                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 195                                 changeServiceState.getErrorCode() == 200);
 196                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 197
 198                 // getting to version 2.5
 199                 for (int x = 0; x < 5; x++) {
 200                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 201                                         LifeCycleStatesEnum.CHECKIN);
 202                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 203                                         LifeCycleStatesEnum.CHECKOUT);
 204                         origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 205                 }
 206
 207                 // validate get response
 208                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 209                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 210                 Map<String, String> getVersionsMap = res.getAllVersions();
 211                 assertTrue(origVersionsMap.equals(getVersionsMap));
 212         }
 213
 214         @Test
 215         public void GetAllServiceVersions_ReadyForCertification_version05() throws Exception {
 216                 // addMandatoryArtifactsToService();
 217                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 218                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 219                 for (int x = 0; x < 4; x++) {
 220                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 221                                         LifeCycleStatesEnum.CHECKIN);
 222                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 223                                         LifeCycleStatesEnum.CHECKOUT);
 224                         origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 225                 }
 226
 227                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 228                                 LifeCycleStatesEnum.CHECKIN);
 229                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 230                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 231
 232                 // validate get response
 233                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 234                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 235                 Map<String, String> getVersionsMap = res.getAllVersions();
 236                 assertTrue(origVersionsMap.equals(getVersionsMap));
 237         }
 238
 239         @Test
 240         public void GetAllServiceVersions_CertifactionInProgress_version05() throws Exception {
 241                 // addMandatoryArtifactsToService();
 242                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 243                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 244                 for (int x = 0; x < 4; x++) {
 245                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 246                                         LifeCycleStatesEnum.CHECKIN);
 247                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 248                                         LifeCycleStatesEnum.CHECKOUT);
 249                         origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 250                 }
 251
 252                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 253                                 LifeCycleStatesEnum.CHECKIN);
 254                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 255                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 256                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails, serviceDetails.getVersion(),
 257                                 LifeCycleStatesEnum.STARTCERTIFICATION);
 258
 259                 // validate get response
 260                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 261                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 262                 Map<String, String> getVersionsMap = res.getAllVersions();
 263                 assertTrue(origVersionsMap.equals(getVersionsMap));
 264         }
 265
 266         @Test
 267         public void GetAllServiceVersions_Certified_version10() throws Exception {
 268                 // addMandatoryArtifactsToService();
 269                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 270                 // get to version 0.5
 271                 for (int x = 0; x < 4; x++) {
 272                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 273                                         LifeCycleStatesEnum.CHECKIN);
 274                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 275                                         LifeCycleStatesEnum.CHECKOUT);
 276
 277                 }
 278
 279                 // get version 1.0
 280                 RestResponse changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 281                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 282                                 changeServiceState.getErrorCode() == 200);
 283                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 284
 285                 // validate get response
 286                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 287                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 288                 Map<String, String> getVersionsMap = res.getAllVersions();
 289                 assertTrue(origVersionsMap.equals(getVersionsMap));
 290         }
 291
 292         @Test
 293         public void GetAllServiceVersions_Certified_version20() throws Exception {
 294                 // addMandatoryArtifactsToService();
 295                 Map<String, String> origVersionsMap = new HashMap<String, String>();
 296                 // get to version 0.5
 297                 for (int x = 0; x < 4; x++) {
 298                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 299                                         LifeCycleStatesEnum.CHECKIN);
 300                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 301                                         LifeCycleStatesEnum.CHECKOUT);
 302                 }
 303
 304                 // get version 1.0
 305                 RestResponse changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 306                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 307                                 changeServiceState.getErrorCode() == 200);
 308                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 309
 310                 // get version 1.5
 311                 for (int x = 0; x < 4; x++) {
 312                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 313                                         LifeCycleStatesEnum.CHECKIN);
 314                         LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 315                                         LifeCycleStatesEnum.CHECKOUT);
 316                 }
 317
 318                 // get version 2.0
 319                 changeServiceState = LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
 320                 assertTrue("certify service request returned status:" + changeServiceState.getErrorCode(),
 321                                 changeServiceState.getErrorCode() == 200);
 322                 origVersionsMap.put(serviceDetails.getVersion(), serviceDetails.getUniqueId());
 323
 324                 // validate get response
 325                 RestResponse serviceGetResponse = ServiceRestUtils.getService(serviceDetails, sdncAdminDetails);
 326                 Service res = ResponseParser.convertServiceResponseToJavaObject(serviceGetResponse.getResponse());
 327                 Map<String, String> getVersionsMap = res.getAllVersions();
 328                 assertTrue(origVersionsMap.equals(getVersionsMap));
 329         }
 330
 331         @Test
 332         public void GetAllServiceVersions_ServiceNotFound() throws Exception {
 333
 334                 RestResponse serviceGetResponse = ServiceRestUtils.getService("123456789", sdncAdminDetails);
 335                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name());
 336                 assertEquals("Check response code after get service without cache", errorInfo.getCode(),
 337                                 serviceGetResponse.getErrorCode());
 338
 339                 List<String> variables = Arrays.asList("123456789");
 340                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), variables,
 341                                 serviceGetResponse.getResponse());
 342
 343         }
 344
 345 }