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.Ignore;
  34 import org.junit.jupiter.api.AfterEach;
  35 import org.junit.jupiter.api.BeforeAll;
  36 import org.junit.jupiter.api.BeforeEach;
  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.persistence.provider.AcDefinitionProvider;
  48 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  49 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  50 import org.onap.policy.models.base.PfModelException;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  52 import org.springframework.beans.factory.annotation.Autowired;
  53 import org.springframework.boot.test.context.SpringBootTest;
  54 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  55 import org.springframework.boot.web.server.LocalServerPort;
  56 import org.springframework.test.context.ActiveProfiles;
  57 import org.springframework.test.context.junit.jupiter.SpringExtension;
  58
  59 /**
  60  * Class to perform unit test of {@link InstantiationController}}.
  61  *
  62  */
  63 @ExtendWith(SpringExtension.class)
  64 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  65 @ActiveProfiles("test")
  66 class InstantiationControllerTest extends CommonRestController {
  67
  68     private static final String AC_INSTANTIATION_CREATE_JSON =
  69             "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 = "instantiation";
  77     private static final String INSTANTIATION_COMMAND_ENDPOINT = "instantiation/command";
  78
  79     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  80     private UUID compositionId;
  81
  82     @Autowired
  83     private AutomationCompositionRepository automationCompositionRepository;
  84
  85     @Autowired
  86     private AcDefinitionProvider acDefinitionProvider;
  87
  88     @Autowired
  89     private AutomationCompositionInstantiationProvider instantiationProvider;
  90
  91     @Autowired
  92     private ParticipantProvider participantProvider;
  93
  94     @LocalServerPort
  95     private int randomServerPort;
  96
  97     @BeforeAll
  98     public static void setUpBeforeClass() {
  99         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 100     }
 101
 102     @BeforeEach
 103     public void populateDb() throws Exception {
 104         createEntryInDB();
 105     }
 106
 107     @BeforeEach
 108     public void setUpPort() {
 109         super.setHttpPrefix(randomServerPort);
 110     }
 111
 112     @AfterEach
 113     public void cleanDatabase() throws Exception {
 114         deleteEntryInDB();
 115     }
 116
 117     @Ignore
 118     @Test
 119     void testSwagger() {
 120         // TODO: Reimplement using springdoc when Impelmentation endpoint is refactored
 121         super.testSwagger(INSTANTIATION_ENDPOINT);
 122     }
 123
 124     @Test
 125     void testCreate_Unauthorized() {
 126         var automationComposition =
 127                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 128
 129         assertUnauthorizedPost(INSTANTIATION_ENDPOINT, Entity.json(automationComposition));
 130     }
 131
 132     @Test
 133     void testQuery_Unauthorized() {
 134         assertUnauthorizedGet(INSTANTIATION_ENDPOINT);
 135     }
 136
 137     @Test
 138     void testUpdate_Unauthorized() throws Exception {
 139         var automationComposition =
 140                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 141
 142         assertUnauthorizedPut(INSTANTIATION_ENDPOINT, Entity.json(automationComposition));
 143     }
 144
 145     @Test
 146     void testDelete_Unauthorized() {
 147         assertUnauthorizedDelete(INSTANTIATION_ENDPOINT);
 148     }
 149
 150     @Test
 151     void testCommand_Unauthorized() {
 152         var instantiationCommand = InstantiationUtils
 153                 .getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Unauthorized");
 154
 155         assertUnauthorizedPut(INSTANTIATION_COMMAND_ENDPOINT, Entity.json(instantiationCommand));
 156     }
 157
 158     @Test
 159     void testCreate() {
 160         var automationCompositionFromRsc =
 161                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
 162         automationCompositionFromRsc.setCompositionId(compositionId);
 163
 164         var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
 165         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 166         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 167         var instResponse = resp.readEntity(InstantiationResponse.class);
 168         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 169
 170         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
 171                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
 172
 173         assertNotNull(automationCompositionsFromDb);
 174         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 175         assertEquals(automationCompositionFromRsc, automationCompositionsFromDb.getAutomationCompositionList().get(0));
 176
 177     }
 178
 179     @Test
 180     void testCreateBadRequest() {
 181         var automationCompositionFromRsc = InstantiationUtils
 182                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
 183         automationCompositionFromRsc.setCompositionId(compositionId);
 184
 185         var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
 186         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 187         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 188
 189         // testing Bad Request: AC already defined
 190         resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
 191         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 192         var instResponse = resp.readEntity(InstantiationResponse.class);
 193         assertNotNull(instResponse.getErrorDetails());
 194         assertNull(instResponse.getAffectedAutomationComposition());
 195     }
 196
 197     @Test
 198     void testQuery_NoResultWithThisName() {
 199         var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT + "?name=noResultWithThisName");
 200         var rawresp = invocationBuilder.buildGet().invoke();
 201         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 202         var resp = rawresp.readEntity(AutomationCompositions.class);
 203         assertThat(resp.getAutomationCompositionList()).isEmpty();
 204     }
 205
 206     @Test
 207     void testQuery() {
 208         var automationComposition =
 209                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 210         automationComposition.setCompositionId(compositionId);
 211
 212         instantiationProvider.createAutomationComposition(automationComposition);
 213
 214         var invocationBuilder =
 215                 super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationComposition.getKey().getName());
 216         var rawresp = invocationBuilder.buildGet().invoke();
 217         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 218         var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
 219         assertNotNull(automationCompositionsQuery);
 220         assertThat(automationCompositionsQuery.getAutomationCompositionList()).hasSize(1);
 221         assertEquals(automationComposition, automationCompositionsQuery.getAutomationCompositionList().get(0));
 222     }
 223
 224     @Test
 225     void testUpdate() {
 226         var automationCompositionCreate =
 227                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
 228         automationCompositionCreate.setCompositionId(compositionId);
 229
 230         instantiationProvider.createAutomationComposition(automationCompositionCreate);
 231
 232         var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
 233         var automationComposition =
 234                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
 235         automationComposition.setCompositionId(compositionId);
 236         var resp = invocationBuilder.put(Entity.json(automationComposition));
 237         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 238
 239         var instResponse = resp.readEntity(InstantiationResponse.class);
 240         InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 241
 242         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
 243                 automationComposition.getKey().getName(), automationComposition.getKey().getVersion());
 244
 245         assertNotNull(automationCompositionsFromDb);
 246         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 247         assertEquals(automationComposition, automationCompositionsFromDb.getAutomationCompositionList().get(0));
 248     }
 249
 250     @Test
 251     void testDelete() {
 252         var automationCompositionFromRsc =
 253                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 254         automationCompositionFromRsc.setCompositionId(compositionId);
 255
 256         instantiationProvider.createAutomationComposition(automationCompositionFromRsc);
 257
 258         var invocationBuilder =
 259                 super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationCompositionFromRsc.getKey().getName()
 260                         + "&version=" + automationCompositionFromRsc.getKey().getVersion());
 261         var resp = invocationBuilder.delete();
 262         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 263         var instResponse = resp.readEntity(InstantiationResponse.class);
 264         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 265
 266         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
 267                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
 268         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).isEmpty();
 269     }
 270
 271     @Test
 272     void testDeleteBadRequest() {
 273         var automationCompositionFromRsc =
 274                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelBadRequest");
 275         automationCompositionFromRsc.setCompositionId(compositionId);
 276
 277         instantiationProvider.createAutomationComposition(automationCompositionFromRsc);
 278
 279         var invocationBuilder =
 280                 super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationCompositionFromRsc.getKey().getName());
 281         var resp = invocationBuilder.delete();
 282         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 283     }
 284
 285     @Test
 286     void testCommand_NotFound1() {
 287         var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
 288         var resp = invocationBuilder.put(Entity.json(new InstantiationCommand()));
 289         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 290     }
 291
 292     @Test
 293     void testCommand_NotFound2() {
 294         var command =
 295                 InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Command");
 296         command.setOrderedState(null);
 297
 298         var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
 299         var resp = invocationBuilder.put(Entity.json(command));
 300         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 301     }
 302
 303     @Test
 304     void testCommand() throws PfModelException {
 305         var automationComposition =
 306                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
 307         automationComposition.setCompositionId(compositionId);
 308         instantiationProvider.createAutomationComposition(automationComposition);
 309
 310         var participants = CommonTestData.createParticipants();
 311         for (var participant : participants) {
 312             participantProvider.saveParticipant(participant);
 313         }
 314
 315         var command =
 316                 InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Command");
 317
 318         var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
 319         var resp = invocationBuilder.put(Entity.json(command));
 320         assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 321         InstantiationResponse instResponse = resp.readEntity(InstantiationResponse.class);
 322         InstantiationUtils.assertInstantiationResponse(instResponse, command);
 323
 324         // check passive state on DB
 325         var toscaConceptIdentifier = command.getAutomationCompositionIdentifier();
 326         var automationCompositionsGet = instantiationProvider
 327                 .getAutomationCompositions(toscaConceptIdentifier.getName(), toscaConceptIdentifier.getVersion());
 328         assertThat(automationCompositionsGet.getAutomationCompositionList()).hasSize(1);
 329         assertEquals(command.getOrderedState(),
 330                 automationCompositionsGet.getAutomationCompositionList().get(0).getOrderedState());
 331     }
 332
 333     private synchronized void deleteEntryInDB() throws Exception {
 334         automationCompositionRepository.deleteAll();
 335         var list = acDefinitionProvider.getAllAcDefinitions();
 336         if (!list.isEmpty()) {
 337             acDefinitionProvider.deleteAcDefintion(compositionId);
 338         }
 339     }
 340
 341     private synchronized void createEntryInDB() throws Exception {
 342         deleteEntryInDB();
 343         var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
 344         compositionId = acmDefinition.getCompositionId();
 345     }
 346 }