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