gerrit.onap Code Review - policy/clamp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2024 Nordix Foundation.
   4  *  Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.clamp.acm.runtime.instantiation.rest;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.assertNotNull;
  27 import static org.junit.jupiter.api.Assertions.assertNull;
  28 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  29 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_VERSIONING;
  30
  31 import jakarta.ws.rs.client.Entity;
  32 import jakarta.ws.rs.core.Response;
  33 import java.util.UUID;
  34 import org.junit.jupiter.api.BeforeAll;
  35 import org.junit.jupiter.api.BeforeEach;
  36 import org.junit.jupiter.api.Test;
  37 import org.junit.jupiter.api.extension.ExtendWith;
  38 import org.onap.policy.clamp.acm.runtime.instantiation.AutomationCompositionInstantiationProvider;
  39 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  40 import org.onap.policy.clamp.acm.runtime.main.rest.InstantiationController;
  41 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  42 import org.onap.policy.clamp.acm.runtime.util.rest.CommonRestController;
  43 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  45 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  46 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
  50 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  51 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  53 import org.springframework.beans.factory.annotation.Autowired;
  54 import org.springframework.boot.test.context.SpringBootTest;
  55 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  56 import org.springframework.boot.test.web.server.LocalServerPort;
  57 import org.springframework.test.context.ActiveProfiles;
  58 import org.springframework.test.context.junit.jupiter.SpringExtension;
  59
  60 /**
  61  * Class to perform unit test of {@link InstantiationController}}.
  62  *
  63  */
  64 @ExtendWith(SpringExtension.class)
  65 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  66 @ActiveProfiles({ "test", "default" })
  67 class InstantiationControllerTest extends CommonRestController {
  68
  69     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  70     private static final String AC_VERSIONING_YAML = "src/test/resources/rest/acm/AutomationCompositionVersioning.yaml";
  71
  72     private static final String AC_INSTANTIATION_UPDATE_JSON =
  73             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  74
  75     private static final String INSTANTIATION_ENDPOINT = "compositions/%s/instances";
  76
  77     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  78
  79     private static final String NODE_TYPE = "org.onap.policy.clamp.acm.AutomationComposition";
  80
  81     @Autowired
  82     private AcDefinitionProvider acDefinitionProvider;
  83
  84     @Autowired
  85     private ParticipantProvider participantProvider;
  86
  87     @Autowired
  88     private AutomationCompositionInstantiationProvider instantiationProvider;
  89
  90     @LocalServerPort
  91     private int randomServerPort;
  92
  93     @BeforeAll
  94     public static void setUpBeforeClass() {
  95         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  96     }
  97
  98     @BeforeEach
  99     public void setUpPort() {
 100         super.setHttpPrefix(randomServerPort);
 101     }
 102
 103     private String getInstanceEndPoint(UUID compositionId) {
 104         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString());
 105     }
 106
 107     private String getInstanceEndPoint(UUID compositionId, UUID instanceId) {
 108         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString()) + "/" + instanceId;
 109     }
 110
 111     @Test
 112     void testSwagger() {
 113         super.testSwagger(String.format(INSTANTIATION_ENDPOINT, "{compositionId}"));
 114     }
 115
 116     @Test
 117     void testCreate_Unauthorized() {
 118         var automationComposition =
 119                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 120
 121         assertUnauthorizedPost(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 122     }
 123
 124     @Test
 125     void testQuery_Unauthorized() {
 126         assertUnauthorizedGet(getInstanceEndPoint(UUID.randomUUID()));
 127     }
 128
 129     @Test
 130     void testUpdate_Unauthorized() {
 131         var automationComposition =
 132                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 133
 134         assertUnauthorizedPut(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 135     }
 136
 137     @Test
 138     void testDelete_Unauthorized() {
 139         assertUnauthorizedDelete(getInstanceEndPoint(UUID.randomUUID()));
 140     }
 141
 142     @Test
 143     void testCreate() {
 144         var compositionId = createAcDefinitionInDB("Create");
 145         var automationCompositionFromRsc =
 146                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
 147         automationCompositionFromRsc.setCompositionId(compositionId);
 148
 149         var instResponse = createAutomationComposition(compositionId, automationCompositionFromRsc,
 150             Response.Status.CREATED);
 151         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 152         automationCompositionFromRsc.setInstanceId(instResponse.getInstanceId());
 153         automationCompositionFromRsc.getElements().values()
 154                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 155
 156         var automationCompositionFromDb =
 157                 instantiationProvider.getAutomationComposition(compositionId, instResponse.getInstanceId());
 158         automationCompositionFromRsc.setLastMsg(automationCompositionFromDb.getLastMsg());
 159
 160         assertNotNull(automationCompositionFromDb);
 161         assertEquals(automationCompositionFromRsc, automationCompositionFromDb);
 162     }
 163
 164     private InstantiationResponse createAutomationComposition(UUID compositionId,
 165         AutomationComposition automationComposition, Response.Status statusExpected) {
 166         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 167         try (var resp = invocationBuilder.post(Entity.json(automationComposition))) {
 168             assertEquals(statusExpected.getStatusCode(), resp.getStatus());
 169             return resp.readEntity(InstantiationResponse.class);
 170         }
 171     }
 172
 173     @Test
 174     void testCreateBadRequest() {
 175         var compositionId = createAcDefinitionInDB("CreateBadRequest");
 176         var automationCompositionFromRsc = InstantiationUtils
 177                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
 178         automationCompositionFromRsc.setCompositionId(compositionId);
 179
 180         createAutomationComposition(compositionId, automationCompositionFromRsc, Response.Status.CREATED);
 181
 182         // testing Bad Request: AC already defined
 183         var instResponse = createAutomationComposition(compositionId, automationCompositionFromRsc,
 184             Response.Status.BAD_REQUEST);
 185         assertNotNull(instResponse.getErrorDetails());
 186         assertNull(instResponse.getAffectedAutomationComposition());
 187     }
 188
 189     @Test
 190     void testVersioning() {
 191         var serviceTemplateVer = InstantiationUtils.getToscaServiceTemplate(TOSCA_VERSIONING);
 192         var compositionId = createAcDefinitionInDB(serviceTemplateVer);
 193         var automationCompositionFromRsc = InstantiationUtils
 194             .getAutomationCompositionFromYaml(AC_VERSIONING_YAML, "Versioning");
 195         automationCompositionFromRsc.setCompositionId(compositionId);
 196         var instResponse =
 197             createAutomationComposition(compositionId, automationCompositionFromRsc, Response.Status.CREATED);
 198         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 199     }
 200
 201     @Test
 202     void testQuery_NoResultWithThisName() {
 203         var invocationBuilder =
 204                 super.sendRequest(getInstanceEndPoint(UUID.randomUUID()) + "?name=noResultWithThisName");
 205         var rawresp = invocationBuilder.buildGet().invoke();
 206         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 207         var resp = rawresp.readEntity(AutomationCompositions.class);
 208         assertThat(resp.getAutomationCompositionList()).isEmpty();
 209     }
 210
 211     @Test
 212     void testQuery() {
 213         var compositionId = createAcDefinitionInDB("Query");
 214         var automationComposition =
 215                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 216         automationComposition.setCompositionId(compositionId);
 217
 218         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 219
 220         var invocationBuilder = super.sendRequest(
 221                 getInstanceEndPoint(compositionId) + "?name=" + automationComposition.getKey().getName());
 222         var rawresp = invocationBuilder.buildGet().invoke();
 223         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 224         var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
 225         assertNotNull(automationCompositionsQuery);
 226         assertThat(automationCompositionsQuery.getAutomationCompositionList()).hasSize(1);
 227         var automationCompositionRc = automationCompositionsQuery.getAutomationCompositionList().get(0);
 228         automationComposition.setLastMsg(automationCompositionRc.getLastMsg());
 229         assertEquals(automationComposition, automationCompositionRc);
 230     }
 231
 232     @Test
 233     void testGet() {
 234         var compositionId = createAcDefinitionInDB("Get");
 235         var automationComposition =
 236                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Get");
 237         automationComposition.setCompositionId(compositionId);
 238
 239         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 240
 241         var invocationBuilder = super.sendRequest(
 242                 getInstanceEndPoint(compositionId, automationComposition.getInstanceId()));
 243         var rawresp = invocationBuilder.buildGet().invoke();
 244         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 245         var automationCompositionGet = rawresp.readEntity(AutomationComposition.class);
 246         assertNotNull(automationCompositionGet);
 247         automationComposition.setLastMsg(automationCompositionGet.getLastMsg());
 248         assertEquals(automationComposition, automationCompositionGet);
 249     }
 250
 251     @Test
 252     void testUpdate() {
 253         var compositionId = createAcDefinitionInDB("Update");
 254         var automationCompositionCreate =
 255                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
 256         automationCompositionCreate.setCompositionId(compositionId);
 257
 258         var response = instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate);
 259
 260         var automationComposition =
 261                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
 262         automationComposition.setCompositionId(compositionId);
 263         automationComposition.setInstanceId(response.getInstanceId());
 264         automationComposition.getElements().values()
 265                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 266
 267         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 268         var resp = invocationBuilder.post(Entity.json(automationComposition));
 269         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 270
 271         var instResponse = resp.readEntity(InstantiationResponse.class);
 272         InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 273
 274         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 275                 automationComposition.getKey().getName(), automationComposition.getKey().getVersion());
 276
 277         assertNotNull(automationCompositionsFromDb);
 278         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 279         var acFromDb = automationCompositionsFromDb.getAutomationCompositionList().get(0);
 280         automationComposition.setLastMsg(acFromDb.getLastMsg());
 281         assertEquals(automationComposition, acFromDb);
 282     }
 283
 284     @Test
 285     void testDelete() {
 286         var compositionId = createAcDefinitionInDB("Delete");
 287         var automationCompositionFromRsc =
 288                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 289         automationCompositionFromRsc.setCompositionId(compositionId);
 290
 291         var instResponse =
 292                 instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 293
 294         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 295         var resp = invocationBuilder.delete();
 296         assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 297         instResponse = resp.readEntity(InstantiationResponse.class);
 298         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 299
 300         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 301                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
 302         assertEquals(DeployState.DELETING,
 303                 automationCompositionsFromDb.getAutomationCompositionList().get(0).getDeployState());
 304     }
 305
 306     @Test
 307     void testDeleteNotFound() {
 308         var compositionId = createAcDefinitionInDB("DeleteNotFound");
 309         var automationCompositionFromRsc =
 310                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
 311         automationCompositionFromRsc.setCompositionId(compositionId);
 312
 313         instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 314
 315         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 316         var resp = invocationBuilder.delete();
 317         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 318     }
 319
 320     @Test
 321     void testDeploy_NotFound() {
 322         var compositionId = createAcDefinitionInDB("Deploy_NotFound");
 323         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 324         var resp = invocationBuilder.put(Entity.json(new AcInstanceStateUpdate()));
 325         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 326     }
 327
 328     @Test
 329     void testDeploy_BadRequest() {
 330         var compositionId = createAcDefinitionInDB("Deploy_BadRequest");
 331         var acFromRsc =
 332                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "BadRequest");
 333         acFromRsc.setCompositionId(compositionId);
 334
 335         var instResponse = instantiationProvider.createAutomationComposition(compositionId, acFromRsc);
 336
 337         var command = new AcInstanceStateUpdate();
 338         command.setDeployOrder(null);
 339         command.setLockOrder(null);
 340
 341         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 342         var resp = invocationBuilder.put(Entity.json(command));
 343         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 344     }
 345
 346     @Test
 347     void testDeploy() {
 348         var compositionId = createAcDefinitionInDB("Deploy");
 349         var automationComposition =
 350                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
 351         automationComposition.setCompositionId(compositionId);
 352         var instResponse = instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 353
 354         var instantiationUpdate = new AcInstanceStateUpdate();
 355         instantiationUpdate.setDeployOrder(DeployOrder.DEPLOY);
 356         instantiationUpdate.setLockOrder(null);
 357
 358         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 359         var resp = invocationBuilder.put(Entity.json(instantiationUpdate));
 360         assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 361     }
 362
 363     private UUID createAcDefinitionInDB(String name) {
 364         var serviceTemplateCreate = new ToscaServiceTemplate(serviceTemplate);
 365         serviceTemplateCreate.setName(name);
 366         return createAcDefinitionInDB(serviceTemplateCreate);
 367     }
 368
 369     private UUID createAcDefinitionInDB(ToscaServiceTemplate serviceTemplateCreate) {
 370         var acmDefinition = CommonTestData.createAcDefinition(serviceTemplateCreate, AcTypeState.PRIMED);
 371         acDefinitionProvider.updateAcDefinition(acmDefinition, NODE_TYPE);
 372         saveDummyParticipantInDb();
 373         return acmDefinition.getCompositionId();
 374     }
 375
 376     private void saveDummyParticipantInDb() {
 377         participantProvider.saveParticipant(CommonTestData.createParticipant(CommonTestData.getParticipantId()));
 378     }
 379 }