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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2023 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
  30 import java.util.UUID;
  31 import javax.ws.rs.client.Entity;
  32 import javax.ws.rs.core.Response;
  33 import org.junit.jupiter.api.BeforeAll;
  34 import org.junit.jupiter.api.BeforeEach;
  35 import org.junit.jupiter.api.Test;
  36 import org.junit.jupiter.api.extension.ExtendWith;
  37 import org.onap.policy.clamp.acm.runtime.instantiation.AutomationCompositionInstantiationProvider;
  38 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  39 import org.onap.policy.clamp.acm.runtime.main.rest.InstantiationController;
  40 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  41 import org.onap.policy.clamp.acm.runtime.util.rest.CommonRestController;
  42 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  43 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  45 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  46 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
  48 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  50 import org.springframework.beans.factory.annotation.Autowired;
  51 import org.springframework.boot.test.context.SpringBootTest;
  52 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  53 import org.springframework.boot.test.web.server.LocalServerPort;
  54 import org.springframework.test.context.ActiveProfiles;
  55 import org.springframework.test.context.junit.jupiter.SpringExtension;
  56
  57 /**
  58  * Class to perform unit test of {@link InstantiationController}}.
  59  *
  60  */
  61 @ExtendWith(SpringExtension.class)
  62 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  63 @ActiveProfiles({ "test", "default" })
  64 class InstantiationControllerTest extends CommonRestController {
  65
  66     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  67
  68     private static final String AC_INSTANTIATION_UPDATE_JSON =
  69             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  70
  71     private static final String INSTANTIATION_ENDPOINT = "compositions/%s/instances";
  72
  73     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  74
  75     @Autowired
  76     private AcDefinitionProvider acDefinitionProvider;
  77
  78     @Autowired
  79     private AutomationCompositionInstantiationProvider instantiationProvider;
  80
  81     @LocalServerPort
  82     private int randomServerPort;
  83
  84     @BeforeAll
  85     public static void setUpBeforeClass() {
  86         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  87     }
  88
  89     @BeforeEach
  90     public void setUpPort() {
  91         super.setHttpPrefix(randomServerPort);
  92     }
  93
  94     private String getInstanceEndPoint(UUID compositionId) {
  95         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString());
  96     }
  97
  98     private String getInstanceEndPoint(UUID compositionId, UUID instanceId) {
  99         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString()) + "/" + instanceId;
 100     }
 101
 102     @Test
 103     void testSwagger() {
 104         super.testSwagger(String.format(INSTANTIATION_ENDPOINT, "{compositionId}"));
 105     }
 106
 107     @Test
 108     void testCreate_Unauthorized() {
 109         var automationComposition =
 110                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 111
 112         assertUnauthorizedPost(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 113     }
 114
 115     @Test
 116     void testQuery_Unauthorized() {
 117         assertUnauthorizedGet(getInstanceEndPoint(UUID.randomUUID()));
 118     }
 119
 120     @Test
 121     void testUpdate_Unauthorized() {
 122         var automationComposition =
 123                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 124
 125         assertUnauthorizedPut(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 126     }
 127
 128     @Test
 129     void testDelete_Unauthorized() {
 130         assertUnauthorizedDelete(getInstanceEndPoint(UUID.randomUUID()));
 131     }
 132
 133     @Test
 134     void testCreate() {
 135         var compositionId = createAcDefinitionInDB("Create");
 136         var automationCompositionFromRsc =
 137                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
 138         automationCompositionFromRsc.setCompositionId(compositionId);
 139
 140         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 141         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 142         assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
 143         var instResponse = resp.readEntity(InstantiationResponse.class);
 144         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 145         automationCompositionFromRsc.setInstanceId(instResponse.getInstanceId());
 146         automationCompositionFromRsc.getElements().values()
 147                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 148
 149         var automationCompositionFromDb =
 150                 instantiationProvider.getAutomationComposition(compositionId, instResponse.getInstanceId());
 151
 152         assertNotNull(automationCompositionFromDb);
 153         assertEquals(automationCompositionFromRsc, automationCompositionFromDb);
 154     }
 155
 156     @Test
 157     void testCreateBadRequest() {
 158         var compositionId = createAcDefinitionInDB("CreateBadRequest");
 159         var automationCompositionFromRsc = InstantiationUtils
 160                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
 161         automationCompositionFromRsc.setCompositionId(compositionId);
 162
 163         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 164         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 165         assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
 166
 167         // testing Bad Request: AC already defined
 168         resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 169         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 170         var instResponse = resp.readEntity(InstantiationResponse.class);
 171         assertNotNull(instResponse.getErrorDetails());
 172         assertNull(instResponse.getAffectedAutomationComposition());
 173     }
 174
 175     @Test
 176     void testQuery_NoResultWithThisName() {
 177         var invocationBuilder =
 178                 super.sendRequest(getInstanceEndPoint(UUID.randomUUID()) + "?name=noResultWithThisName");
 179         var rawresp = invocationBuilder.buildGet().invoke();
 180         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 181         var resp = rawresp.readEntity(AutomationCompositions.class);
 182         assertThat(resp.getAutomationCompositionList()).isEmpty();
 183     }
 184
 185     @Test
 186     void testQuery() {
 187         var compositionId = createAcDefinitionInDB("Query");
 188         var automationComposition =
 189                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 190         automationComposition.setCompositionId(compositionId);
 191
 192         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 193
 194         var invocationBuilder = super.sendRequest(
 195                 getInstanceEndPoint(compositionId) + "?name=" + automationComposition.getKey().getName());
 196         var rawresp = invocationBuilder.buildGet().invoke();
 197         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 198         var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
 199         assertNotNull(automationCompositionsQuery);
 200         assertThat(automationCompositionsQuery.getAutomationCompositionList()).hasSize(1);
 201         assertEquals(automationComposition, automationCompositionsQuery.getAutomationCompositionList().get(0));
 202     }
 203
 204     @Test
 205     void testGet() {
 206         var compositionId = createAcDefinitionInDB("Get");
 207         var automationComposition =
 208                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Get");
 209         automationComposition.setCompositionId(compositionId);
 210
 211         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 212
 213         var invocationBuilder = super.sendRequest(
 214                 getInstanceEndPoint(compositionId, automationComposition.getInstanceId()));
 215         var rawresp = invocationBuilder.buildGet().invoke();
 216         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 217         var automationCompositionGet = rawresp.readEntity(AutomationComposition.class);
 218         assertNotNull(automationCompositionGet);
 219         assertEquals(automationComposition, automationCompositionGet);
 220     }
 221
 222     @Test
 223     void testUpdate() {
 224         var compositionId = createAcDefinitionInDB("Update");
 225         var automationCompositionCreate =
 226                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
 227         automationCompositionCreate.setCompositionId(compositionId);
 228
 229         var response = instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate);
 230
 231         var automationComposition =
 232                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
 233         automationComposition.setCompositionId(compositionId);
 234         automationComposition.setInstanceId(response.getInstanceId());
 235         automationComposition.getElements().values()
 236                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 237
 238         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 239         var resp = invocationBuilder.post(Entity.json(automationComposition));
 240         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 241
 242         var instResponse = resp.readEntity(InstantiationResponse.class);
 243         InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 244
 245         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 246                 automationComposition.getKey().getName(), automationComposition.getKey().getVersion());
 247
 248         assertNotNull(automationCompositionsFromDb);
 249         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 250         assertEquals(automationComposition, automationCompositionsFromDb.getAutomationCompositionList().get(0));
 251     }
 252
 253     @Test
 254     void testDelete() {
 255         var compositionId = createAcDefinitionInDB("Delete");
 256         var automationCompositionFromRsc =
 257                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 258         automationCompositionFromRsc.setCompositionId(compositionId);
 259
 260         var instResponse =
 261                 instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 262
 263         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 264         var resp = invocationBuilder.delete();
 265         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 266         instResponse = resp.readEntity(InstantiationResponse.class);
 267         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 268
 269         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 270                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
 271         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).isEmpty();
 272     }
 273
 274     @Test
 275     void testDeleteNotFound() {
 276         var compositionId = createAcDefinitionInDB("DeleteNotFound");
 277         var automationCompositionFromRsc =
 278                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
 279         automationCompositionFromRsc.setCompositionId(compositionId);
 280
 281         instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 282
 283         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 284         var resp = invocationBuilder.delete();
 285         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 286     }
 287
 288     @Test
 289     void testDeploy_NotFound() {
 290         var compositionId = createAcDefinitionInDB("Deploy_NotFound");
 291         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 292         var resp = invocationBuilder.put(Entity.json(new AcInstanceStateUpdate()));
 293         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 294     }
 295
 296     @Test
 297     void testDeploy_BadRequest() {
 298         var compositionId = createAcDefinitionInDB("Deploy_BadRequest");
 299         var acFromRsc =
 300                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "BadRequest");
 301         acFromRsc.setCompositionId(compositionId);
 302
 303         var instResponse = instantiationProvider.createAutomationComposition(compositionId, acFromRsc);
 304
 305         var command = new AcInstanceStateUpdate();
 306         command.setDeployOrder(null);
 307         command.setLockOrder(null);
 308
 309         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 310         var resp = invocationBuilder.put(Entity.json(command));
 311         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 312     }
 313
 314     @Test
 315     void testDeploy() {
 316         var compositionId = createAcDefinitionInDB("Deploy");
 317         var automationComposition =
 318                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
 319         automationComposition.setCompositionId(compositionId);
 320         var instResponse = instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 321
 322         var instantiationUpdate = new AcInstanceStateUpdate();
 323         instantiationUpdate.setDeployOrder(DeployOrder.DEPLOY);
 324         instantiationUpdate.setLockOrder(null);
 325
 326         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 327         var resp = invocationBuilder.put(Entity.json(instantiationUpdate));
 328         assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 329     }
 330
 331     private UUID createAcDefinitionInDB(String name) {
 332         var serviceTemplateCreate = new ToscaServiceTemplate(serviceTemplate);
 333         serviceTemplateCreate.setName(name);
 334         var acmDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 335         acDefinitionProvider.updateAcDefinition(acmDefinition);
 336         return acmDefinition.getCompositionId();
 337     }
 338 }