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