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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2022 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.AfterEach;
  34 import org.junit.jupiter.api.BeforeAll;
  35 import org.junit.jupiter.api.BeforeEach;
  36 import org.junit.jupiter.api.Disabled;
  37 import org.junit.jupiter.api.Test;
  38 import org.junit.jupiter.api.extension.ExtendWith;
  39 import org.onap.policy.clamp.acm.runtime.instantiation.AutomationCompositionInstantiationProvider;
  40 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  41 import org.onap.policy.clamp.acm.runtime.main.rest.InstantiationController;
  42 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  43 import org.onap.policy.clamp.acm.runtime.util.rest.CommonRestController;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  45 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
  46 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
  48 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  49 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  50 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  51 import org.onap.policy.models.base.PfModelException;
  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.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
  71     private static final String AC_INSTANTIATION_UPDATE_JSON =
  72             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  73
  74     private static final String AC_INSTANTIATION_CHANGE_STATE_JSON = "src/test/resources/rest/acm/PassiveCommand.json";
  75
  76     private static final String INSTANTIATION_ENDPOINT = "compositions/%s/instances";
  77
  78     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  79     private UUID compositionId = UUID.randomUUID();
  80
  81     @Autowired
  82     private AutomationCompositionRepository automationCompositionRepository;
  83
  84     @Autowired
  85     private AcDefinitionProvider acDefinitionProvider;
  86
  87     @Autowired
  88     private AutomationCompositionInstantiationProvider instantiationProvider;
  89
  90     @Autowired
  91     private ParticipantProvider participantProvider;
  92
  93     @LocalServerPort
  94     private int randomServerPort;
  95
  96     @BeforeAll
  97     public static void setUpBeforeClass() {
  98         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  99     }
 100
 101     @BeforeEach
 102     public void populateDb() {
 103         createEntryInDB();
 104     }
 105
 106     @BeforeEach
 107     public void setUpPort() {
 108         super.setHttpPrefix(randomServerPort);
 109     }
 110
 111     @AfterEach
 112     public void cleanDatabase() {
 113         deleteEntryInDB();
 114     }
 115
 116     private String getInstanceEndPoint() {
 117         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString());
 118     }
 119
 120     private String getInstanceEndPoint(UUID instanceId) {
 121         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString()) + "/" + instanceId;
 122     }
 123
 124     @Test
 125     void testSwagger() {
 126         super.testSwagger(String.format(INSTANTIATION_ENDPOINT, "{compositionId}"));
 127     }
 128
 129     @Test
 130     void testCreate_Unauthorized() {
 131         var automationComposition =
 132                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 133
 134         assertUnauthorizedPost(getInstanceEndPoint(), Entity.json(automationComposition));
 135     }
 136
 137     @Test
 138     void testQuery_Unauthorized() {
 139         assertUnauthorizedGet(getInstanceEndPoint());
 140     }
 141
 142     @Test
 143     void testUpdate_Unauthorized() {
 144         var automationComposition =
 145                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 146
 147         assertUnauthorizedPut(getInstanceEndPoint(), Entity.json(automationComposition));
 148     }
 149
 150     @Test
 151     void testDelete_Unauthorized() {
 152         assertUnauthorizedDelete(getInstanceEndPoint());
 153     }
 154
 155     @Test
 156     void testCreate() {
 157         var automationCompositionFromRsc =
 158                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
 159         automationCompositionFromRsc.setCompositionId(compositionId);
 160
 161         var invocationBuilder = super.sendRequest(getInstanceEndPoint());
 162         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 163         assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
 164         var instResponse = resp.readEntity(InstantiationResponse.class);
 165         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 166         automationCompositionFromRsc.setInstanceId(instResponse.getInstanceId());
 167
 168         var automationCompositionFromDb =
 169                 instantiationProvider.getAutomationComposition(compositionId, instResponse.getInstanceId());
 170
 171         assertNotNull(automationCompositionFromDb);
 172         assertEquals(automationCompositionFromRsc, automationCompositionFromDb);
 173
 174     }
 175
 176     @Test
 177     void testCreateBadRequest() {
 178         var automationCompositionFromRsc = InstantiationUtils
 179                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
 180         automationCompositionFromRsc.setCompositionId(compositionId);
 181
 182         var invocationBuilder = super.sendRequest(getInstanceEndPoint());
 183         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 184         assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
 185
 186         // testing Bad Request: AC already defined
 187         resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 188         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 189         var instResponse = resp.readEntity(InstantiationResponse.class);
 190         assertNotNull(instResponse.getErrorDetails());
 191         assertNull(instResponse.getAffectedAutomationComposition());
 192     }
 193
 194     @Test
 195     void testQuery_NoResultWithThisName() {
 196         var invocationBuilder = super.sendRequest(getInstanceEndPoint() + "?name=noResultWithThisName");
 197         var rawresp = invocationBuilder.buildGet().invoke();
 198         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 199         var resp = rawresp.readEntity(AutomationCompositions.class);
 200         assertThat(resp.getAutomationCompositionList()).isEmpty();
 201     }
 202
 203     @Test
 204     void testQuery() {
 205         var automationComposition =
 206                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 207         automationComposition.setCompositionId(compositionId);
 208
 209         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 210
 211         var invocationBuilder =
 212                 super.sendRequest(getInstanceEndPoint() + "?name=" + automationComposition.getKey().getName());
 213         var rawresp = invocationBuilder.buildGet().invoke();
 214         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 215         var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
 216         assertNotNull(automationCompositionsQuery);
 217         assertThat(automationCompositionsQuery.getAutomationCompositionList()).hasSize(1);
 218         assertEquals(automationComposition, automationCompositionsQuery.getAutomationCompositionList().get(0));
 219     }
 220
 221     @Disabled
 222     @Test
 223     void testUpdate() {
 224         var automationCompositionCreate =
 225                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
 226         automationCompositionCreate.setCompositionId(compositionId);
 227
 228         var response = instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate);
 229
 230         var automationComposition =
 231                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
 232         automationComposition.setCompositionId(compositionId);
 233         automationComposition.setInstanceId(response.getInstanceId());
 234         var instantiationUpdate = new InstantiationUpdate();
 235         instantiationUpdate.setElements(automationComposition.getElements());
 236         var invocationBuilder = super.sendRequest(getInstanceEndPoint(response.getInstanceId()));
 237         var resp = invocationBuilder.put(Entity.json(automationComposition));
 238         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 239
 240         var instResponse = resp.readEntity(InstantiationResponse.class);
 241         InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 242
 243         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 244                 automationComposition.getKey().getName(), automationComposition.getKey().getVersion());
 245
 246         assertNotNull(automationCompositionsFromDb);
 247         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 248         assertEquals(automationComposition, automationCompositionsFromDb.getAutomationCompositionList().get(0));
 249     }
 250
 251     @Test
 252     void testDelete() {
 253         var automationCompositionFromRsc =
 254                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 255         automationCompositionFromRsc.setCompositionId(compositionId);
 256
 257         var instResponse =
 258                 instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 259
 260         var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
 261         var resp = invocationBuilder.delete();
 262         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 263         instResponse = resp.readEntity(InstantiationResponse.class);
 264         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 265
 266         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 267                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
 268         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).isEmpty();
 269     }
 270
 271     @Test
 272     void testDeleteNotFound() {
 273         var automationCompositionFromRsc =
 274                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
 275         automationCompositionFromRsc.setCompositionId(compositionId);
 276
 277         instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 278
 279         var invocationBuilder = super.sendRequest(getInstanceEndPoint(UUID.randomUUID()));
 280         var resp = invocationBuilder.delete();
 281         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 282     }
 283
 284     @Disabled
 285     @Test
 286     void testCommand_NotFound1() {
 287         var invocationBuilder = super.sendRequest(getInstanceEndPoint(UUID.randomUUID()));
 288         var resp = invocationBuilder.put(Entity.json(new InstantiationUpdate()));
 289         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 290     }
 291
 292     @Disabled
 293     @Test
 294     void testCommand_NotFound2() {
 295         var acFromRsc =
 296                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
 297         acFromRsc.setCompositionId(compositionId);
 298
 299         var instResponse = instantiationProvider.createAutomationComposition(compositionId, acFromRsc);
 300
 301         var command = new InstantiationUpdate();
 302         command.setInstantiationCommand(new InstantiationCommand());
 303         command.getInstantiationCommand().setOrderedState(null);
 304
 305         var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
 306         var resp = invocationBuilder.put(Entity.json(command));
 307         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 308     }
 309
 310     @Disabled
 311     @Test
 312     void testCommand() throws PfModelException {
 313         var automationComposition =
 314                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
 315         automationComposition.setCompositionId(compositionId);
 316         var instResponse = instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 317
 318         var participants = CommonTestData.createParticipants();
 319         for (var participant : participants) {
 320             participantProvider.saveParticipant(participant);
 321         }
 322
 323         var instantiationUpdate = new InstantiationUpdate();
 324         var command = InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON);
 325         instantiationUpdate.setInstantiationCommand(command);
 326
 327         var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
 328         var resp = invocationBuilder.put(Entity.json(instantiationUpdate));
 329         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 330         instResponse = resp.readEntity(InstantiationResponse.class);
 331         InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 332
 333         // check passive state on DB
 334         var toscaConceptIdentifier = instResponse.getAffectedAutomationComposition();
 335         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 336                 toscaConceptIdentifier.getName(), toscaConceptIdentifier.getVersion());
 337         assertThat(automationCompositionsGet.getAutomationCompositionList()).hasSize(1);
 338         assertEquals(command.getOrderedState(),
 339                 automationCompositionsGet.getAutomationCompositionList().get(0).getOrderedState());
 340     }
 341
 342     private synchronized void deleteEntryInDB() {
 343         automationCompositionRepository.deleteAll();
 344         var list = acDefinitionProvider.findAcDefinition(compositionId);
 345         if (!list.isEmpty()) {
 346             acDefinitionProvider.deleteAcDefintion(compositionId);
 347         }
 348     }
 349
 350     private synchronized void createEntryInDB() {
 351         deleteEntryInDB();
 352         var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
 353         compositionId = acmDefinition.getCompositionId();
 354     }
 355 }