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