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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
   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 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_VERSIONING;
  30
  31 import jakarta.ws.rs.client.Entity;
  32 import jakarta.ws.rs.core.MediaType;
  33 import jakarta.ws.rs.core.Response;
  34 import java.util.UUID;
  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.AcTypeState;
  45 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  46 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  47 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  50 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
  51 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  52 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  53 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  54 import org.springframework.beans.factory.annotation.Autowired;
  55 import org.springframework.boot.test.context.SpringBootTest;
  56 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  57 import org.springframework.boot.test.web.server.LocalServerPort;
  58 import org.springframework.data.domain.Pageable;
  59 import org.springframework.test.annotation.DirtiesContext;
  60 import org.springframework.test.context.ActiveProfiles;
  61 import org.springframework.test.context.junit.jupiter.SpringExtension;
  62
  63 /**
  64  * Class to perform unit test of {@link InstantiationController}}.
  65  *
  66  */
  67 @ExtendWith(SpringExtension.class)
  68 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  69 @ActiveProfiles({ "test", "default" })
  70 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
  71 class InstantiationControllerTest extends CommonRestController {
  72
  73     private static final int NUMBER_INSTANCES = 10;
  74     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  75     private static final String AC_VERSIONING_YAML = "src/test/resources/rest/acm/AutomationCompositionVersioning.yaml";
  76
  77     private static final String AC_INSTANTIATION_UPDATE_JSON =
  78             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  79
  80     private static final String INSTANTIATION_ENDPOINT = "compositions/%s/instances";
  81
  82     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  83
  84     private static final String NODE_TYPE = "org.onap.policy.clamp.acm.AutomationComposition";
  85
  86     @Autowired
  87     private AcDefinitionProvider acDefinitionProvider;
  88
  89     @Autowired
  90     private ParticipantProvider participantProvider;
  91
  92     @Autowired
  93     private AutomationCompositionInstantiationProvider instantiationProvider;
  94
  95     @LocalServerPort
  96     private int randomServerPort;
  97
  98     @BeforeAll
  99     static void setUpBeforeClass() {
 100         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 101     }
 102
 103     @BeforeEach
 104     void setUpPort() {
 105         super.setHttpPrefix(randomServerPort);
 106     }
 107
 108     private String getInstanceEndPoint(UUID compositionId) {
 109         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString());
 110     }
 111
 112     private String getInstanceEndPoint(UUID compositionId, UUID instanceId) {
 113         return String.format(INSTANTIATION_ENDPOINT, compositionId.toString()) + "/" + instanceId;
 114     }
 115
 116     @Test
 117     void testSwagger() {
 118         super.testSwagger(String.format(INSTANTIATION_ENDPOINT, "{compositionId}"));
 119     }
 120
 121     @Test
 122     void testCreate_Unauthorized() {
 123         var automationComposition =
 124                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 125
 126         assertUnauthorizedPost(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 127     }
 128
 129     @Test
 130     void testQuery_Unauthorized() {
 131         assertUnauthorizedGet(getInstanceEndPoint(UUID.randomUUID()));
 132     }
 133
 134     @Test
 135     void testUpdate_Unauthorized() {
 136         var automationComposition =
 137                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 138
 139         assertUnauthorizedPut(getInstanceEndPoint(UUID.randomUUID()), Entity.json(automationComposition));
 140     }
 141
 142     @Test
 143     void testDelete_Unauthorized() {
 144         assertUnauthorizedDelete(getInstanceEndPoint(UUID.randomUUID()));
 145     }
 146
 147     @Test
 148     void testCreate() {
 149         var compositionId = createAcDefinitionInDB("Create");
 150         var automationCompositionFromRsc =
 151                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
 152         assertNotNull(automationCompositionFromRsc);
 153         automationCompositionFromRsc.setCompositionId(compositionId);
 154
 155         var instResponse = createAutomationComposition(compositionId, automationCompositionFromRsc,
 156             Response.Status.CREATED);
 157         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 158         automationCompositionFromRsc.setInstanceId(instResponse.getInstanceId());
 159         automationCompositionFromRsc.getElements().values()
 160                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 161
 162         var automationCompositionFromDb =
 163                 instantiationProvider.getAutomationComposition(compositionId, instResponse.getInstanceId());
 164         automationCompositionFromRsc.setLastMsg(automationCompositionFromDb.getLastMsg());
 165
 166         assertNotNull(automationCompositionFromDb);
 167         assertEquals(automationCompositionFromRsc, automationCompositionFromDb);
 168     }
 169
 170     private InstantiationResponse createAutomationComposition(UUID compositionId,
 171         AutomationComposition automationComposition, Response.Status statusExpected) {
 172         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 173         try (var resp = invocationBuilder.post(Entity.json(automationComposition))) {
 174             assertEquals(statusExpected.getStatusCode(), resp.getStatus());
 175             return resp.readEntity(InstantiationResponse.class);
 176         }
 177     }
 178
 179     @Test
 180     void testCreateBadRequest() {
 181         var compositionId = createAcDefinitionInDB("CreateBadRequest");
 182         var automationCompositionFromRsc = InstantiationUtils
 183                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
 184         assertNotNull(automationCompositionFromRsc);
 185         automationCompositionFromRsc.setCompositionId(compositionId);
 186
 187         createAutomationComposition(compositionId, automationCompositionFromRsc, Response.Status.CREATED);
 188
 189         // testing Bad Request: AC already defined
 190         var instResponse = createAutomationComposition(compositionId, automationCompositionFromRsc,
 191             Response.Status.BAD_REQUEST);
 192         assertNotNull(instResponse.getErrorDetails());
 193         assertNull(instResponse.getAffectedAutomationComposition());
 194     }
 195
 196     @Test
 197     void testVersioning() {
 198         var serviceTemplateVer = InstantiationUtils.getToscaServiceTemplate(TOSCA_VERSIONING);
 199         var compositionId = createAcDefinitionInDB(serviceTemplateVer);
 200         var automationCompositionFromRsc = InstantiationUtils
 201             .getAutomationCompositionFromYaml(AC_VERSIONING_YAML, "Versioning");
 202         assertNotNull(automationCompositionFromRsc);
 203         automationCompositionFromRsc.setCompositionId(compositionId);
 204         var instResponse =
 205             createAutomationComposition(compositionId, automationCompositionFromRsc, Response.Status.CREATED);
 206         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 207     }
 208
 209     @Test
 210     void testQuery_NoResultWithThisName() {
 211         var invocationBuilder =
 212                 super.sendRequest(getInstanceEndPoint(UUID.randomUUID()) + "?name=noResultWithThisName");
 213         try (var rawresp = invocationBuilder.buildGet().invoke()) {
 214             assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 215             var resp = rawresp.readEntity(AutomationCompositions.class);
 216             assertThat(resp.getAutomationCompositionList()).isEmpty();
 217         }
 218     }
 219
 220     @Test
 221     void testQuery() {
 222         var compositionId = createAcDefinitionInDB("Query");
 223         var automationComposition =
 224                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 225         assertNotNull(automationComposition);
 226         automationComposition.setCompositionId(compositionId);
 227
 228         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 229
 230         var invocationBuilder = super.sendRequest(
 231                 getInstanceEndPoint(compositionId) + "?name=" + automationComposition.getKey().getName());
 232         try (var rawresp = invocationBuilder.buildGet().invoke()) {
 233             assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 234             var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
 235             assertNotNull(automationCompositionsQuery);
 236             assertThat(automationCompositionsQuery.getAutomationCompositionList()).hasSize(1);
 237             var automationCompositionRc = automationCompositionsQuery.getAutomationCompositionList().get(0);
 238             automationComposition.setLastMsg(automationCompositionRc.getLastMsg());
 239             assertEquals(automationComposition, automationCompositionRc);
 240         }
 241     }
 242
 243     @Test
 244     void testQueryPageable() {
 245         var compositionId = createAcDefinitionInDB("Query");
 246         var automationComposition =
 247             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 248         assertNotNull(automationComposition);
 249         automationComposition.setCompositionId(compositionId);
 250         for (var i = 0; i < NUMBER_INSTANCES; i++) {
 251             automationComposition.setName("acm_" + i);
 252             instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 253         }
 254         var endpoint = getInstanceEndPoint(compositionId);
 255         validateQueryPageable(endpoint + "?name=wrong_name", 0);
 256         validateQueryPageable(endpoint + "?name=acm_1", 1);
 257         validateQueryPageable(endpoint + "?page=1&size=4", 4);
 258
 259         validateQueryNotPageable(endpoint + "?page=0");
 260         validateQueryNotPageable(endpoint + "?size=5");
 261         validateQueryNotPageable(endpoint);
 262     }
 263
 264     private void validateQueryNotPageable(String link) {
 265         var invocationBuilder = super.sendRequest(link);
 266         try (var response = invocationBuilder.buildGet().invoke()) {
 267             assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
 268             var resultList = response.readEntity(AutomationCompositions.class);
 269             assertNotNull(resultList);
 270             assertThat(resultList.getAutomationCompositionList()).hasSizeGreaterThanOrEqualTo(NUMBER_INSTANCES);
 271         }
 272     }
 273
 274     private void validateQueryPageable(String link, int size) {
 275         var invocationBuilder = super.sendRequest(link);
 276         try (var response = invocationBuilder.buildGet().invoke()) {
 277             assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
 278             var resultList = response.readEntity(AutomationCompositions.class);
 279             assertNotNull(resultList);
 280             assertThat(resultList.getAutomationCompositionList()).hasSize(size);
 281         }
 282     }
 283
 284     @Test
 285     void testGet() {
 286         var compositionId = createAcDefinitionInDB("Get");
 287         var automationComposition =
 288                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Get");
 289         assertNotNull(automationComposition);
 290         automationComposition.setCompositionId(compositionId);
 291
 292         instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 293
 294         var invocationBuilder = super.sendRequest(
 295                 getInstanceEndPoint(compositionId, automationComposition.getInstanceId()));
 296         var rawresp = invocationBuilder.buildGet().invoke();
 297         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
 298         var automationCompositionGet = rawresp.readEntity(AutomationComposition.class);
 299         rawresp.close();
 300         assertNotNull(automationCompositionGet);
 301         automationComposition.setLastMsg(automationCompositionGet.getLastMsg());
 302         assertEquals(automationComposition, automationCompositionGet);
 303     }
 304
 305     @Test
 306     void testUpdate() {
 307         var compositionId = createAcDefinitionInDB("Update");
 308         var automationCompositionCreate =
 309                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
 310         assertNotNull(automationCompositionCreate);
 311         automationCompositionCreate.setCompositionId(compositionId);
 312
 313         var response = instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate);
 314
 315         var automationComposition =
 316                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
 317         assertNotNull(automationComposition);
 318         automationComposition.setCompositionId(compositionId);
 319         automationComposition.setInstanceId(response.getInstanceId());
 320         automationComposition.getElements().values()
 321                 .forEach(element -> element.setParticipantId(CommonTestData.getParticipantId()));
 322
 323         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId));
 324         try (var resp = invocationBuilder.post(Entity.json(automationComposition))) {
 325             assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 326
 327             var instResponse = resp.readEntity(InstantiationResponse.class);
 328             InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 329         }
 330         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
 331                 compositionId, automationComposition.getKey().getName(),
 332                 automationComposition.getKey().getVersion(), Pageable.unpaged());
 333
 334         assertNotNull(automationCompositionsFromDb);
 335         assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
 336         var acFromDb = automationCompositionsFromDb.getAutomationCompositionList().get(0);
 337         automationComposition.setLastMsg(acFromDb.getLastMsg());
 338         automationComposition.setRevisionId(acFromDb.getRevisionId());
 339         assertEquals(automationComposition, acFromDb);
 340     }
 341
 342     @Test
 343     void testDelete() {
 344         var compositionId = createAcDefinitionInDB("Delete");
 345         var automationCompositionFromRsc =
 346                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 347         assertNotNull(automationCompositionFromRsc);
 348         automationCompositionFromRsc.setCompositionId(compositionId);
 349
 350         var instResponse =
 351                 instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 352
 353         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 354         try (var resp = invocationBuilder.delete()) {
 355             assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 356             instResponse = resp.readEntity(InstantiationResponse.class);
 357         }
 358         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 359
 360         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(compositionId,
 361                 automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion(),
 362                 Pageable.unpaged());
 363         assertEquals(DeployState.DELETING,
 364                 automationCompositionsFromDb.getAutomationCompositionList().get(0).getDeployState());
 365     }
 366
 367     @Test
 368     void testDeleteNotFound() {
 369         var compositionId = createAcDefinitionInDB("DeleteNotFound");
 370         var automationCompositionFromRsc =
 371                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
 372         assertNotNull(automationCompositionFromRsc);
 373         automationCompositionFromRsc.setCompositionId(compositionId);
 374
 375         instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 376
 377         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 378         try (var resp = invocationBuilder.delete()) {
 379             assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 380         }
 381     }
 382
 383     @Test
 384     void testRollbackNotValid() {
 385         var compositionId = createAcDefinitionInDB("RollbackNotFound");
 386
 387         // instance not found
 388         var url = getInstanceEndPoint(compositionId, UUID.randomUUID()) + "/rollback";
 389         var invocationBuilder = super.sendRequest(url);
 390         try (var resp = invocationBuilder.post(Entity.entity("", MediaType.APPLICATION_JSON))) {
 391             assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 392         }
 393
 394         // instance not valid state
 395         var automationCompositionFromRsc =
 396                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NotValid");
 397         assertNotNull(automationCompositionFromRsc);
 398         automationCompositionFromRsc.setCompositionId(compositionId);
 399         var instanceResponse =
 400                 instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 401         url = getInstanceEndPoint(compositionId, instanceResponse.getInstanceId()) + "/rollback";
 402         invocationBuilder = super.sendRequest(url);
 403         try (var resp = invocationBuilder.post(Entity.entity("", MediaType.APPLICATION_JSON))) {
 404             assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 405         }
 406     }
 407
 408     @Test
 409     void testDeploy_NotFound() {
 410         var compositionId = createAcDefinitionInDB("Deploy_NotFound");
 411         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, UUID.randomUUID()));
 412         try (var resp = invocationBuilder.put(Entity.json(new AcInstanceStateUpdate()))) {
 413             assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
 414         }
 415     }
 416
 417     @Test
 418     void testDeploy_BadRequest() {
 419         var compositionId = createAcDefinitionInDB("Deploy_BadRequest");
 420         var acFromRsc =
 421                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "BadRequest");
 422         assertNotNull(acFromRsc);
 423         acFromRsc.setCompositionId(compositionId);
 424
 425         var instResponse = instantiationProvider.createAutomationComposition(compositionId, acFromRsc);
 426
 427         var command = new AcInstanceStateUpdate();
 428         command.setDeployOrder(null);
 429         command.setLockOrder(null);
 430
 431         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 432         try (var resp = invocationBuilder.put(Entity.json(command))) {
 433             assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 434         }
 435     }
 436
 437     @Test
 438     void testDeploy() {
 439         var compositionId = createAcDefinitionInDB("Deploy");
 440         var automationComposition =
 441                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
 442         assertNotNull(automationComposition);
 443         automationComposition.setCompositionId(compositionId);
 444         var instResponse = instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 445
 446         var instantiationUpdate = new AcInstanceStateUpdate();
 447         instantiationUpdate.setDeployOrder(DeployOrder.DEPLOY);
 448         instantiationUpdate.setLockOrder(null);
 449
 450         var invocationBuilder = super.sendRequest(getInstanceEndPoint(compositionId, instResponse.getInstanceId()));
 451         try (var resp = invocationBuilder.put(Entity.json(instantiationUpdate))) {
 452             assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
 453         }
 454     }
 455
 456     @Test
 457     void test_queryCompositionInstancesByFilter_WithoutCompositionIds() {
 458         // test setup
 459         var compositionId = createAcDefinitionInDB("Query");
 460         var automationComposition =
 461             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 462         assertNotNull(automationComposition);
 463         automationComposition.setCompositionId(compositionId);
 464         for (var i = 0; i < NUMBER_INSTANCES; i++) {
 465             automationComposition.setName("acmr_" + i);
 466             instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 467         }
 468
 469         validateQueryPageable("instances", 10);
 470         validateQueryPageable("instances?page=1&size=4", 4);
 471         validateQueryPageable("instances?size=4", 10); // only works if page is also informed, so listAll
 472         validateQueryPageable("instances?stateChangeResult=FAILED,TIMEOUT", 0);
 473         validateQueryPageable("instances?deployState=UNDEPLOYED", 10);
 474         validateQueryPageable("instances?stateChangeResult=NO_ERROR&deployState=UNDEPLOYED", 0);
 475         validateQueryPageable("instances?sort=name&sortOrder=DESC", 10);
 476     }
 477
 478     @Test
 479     void test_queryCompositionInstancesByFilter_WithCompositionIds() {
 480         // test setup
 481         var compositionId = createAcDefinitionInDB("Query");
 482         var automationComposition =
 483             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
 484         assertNotNull(automationComposition);
 485         automationComposition.setCompositionId(compositionId);
 486         for (var i = 0; i < NUMBER_INSTANCES; i++) {
 487             automationComposition.setName("acmr_" + i);
 488             instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 489         }
 490
 491         validateQueryPageable("instances?compositionIds=" + compositionId, 10);
 492         validateQueryPageable("instances?page=1&size=4&compositionIds=" + compositionId, 4);
 493         validateQueryPageable("instances?size=4&compositionIds=" + compositionId, 10);
 494         validateQueryPageable("instances?stateChangeResult=FAILED,TIMEOUT&compositionIds=" + compositionId, 0);
 495         validateQueryPageable("instances?deployState=UNDEPLOYED&compositionIds=" + compositionId, 10);
 496         validateQueryPageable("instances?sort=name&sortOrder=DESC&compositionIds=" + compositionId, 10);
 497     }
 498
 499     private UUID createAcDefinitionInDB(String name) {
 500         var serviceTemplateCreate = new ToscaServiceTemplate(serviceTemplate);
 501         serviceTemplateCreate.setName(name);
 502         return createAcDefinitionInDB(serviceTemplateCreate);
 503     }
 504
 505     private UUID createAcDefinitionInDB(ToscaServiceTemplate serviceTemplateCreate) {
 506         var acmDefinition = CommonTestData.createAcDefinition(serviceTemplateCreate, AcTypeState.PRIMED);
 507         acDefinitionProvider.updateAcDefinition(acmDefinition, NODE_TYPE);
 508         saveDummyParticipantInDb();
 509         return acmDefinition.getCompositionId();
 510     }
 511
 512     private void saveDummyParticipantInDb() {
 513         var participant = CommonTestData.createParticipant(CommonTestData.getParticipantId());
 514         var replica = CommonTestData.createParticipantReplica(CommonTestData.getReplicaId());
 515         participant.getReplicas().put(replica.getReplicaId(), replica);
 516         participantProvider.saveParticipant(participant);
 517     }
 518 }