rapp-manager-sme/src/test/java/com/oransc/rappmanager/sme/service/SmeDeployerTest.java

   1 /*-
   2  * ============LICENSE_START======================================================================
   3  * Copyright (C) 2023 Nordix Foundation. All rights reserved.
   4  * Copyright (C) 2024 OpenInfra Foundation Europe. 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  * ============LICENSE_END========================================================================
  18  */
  19
  20 package com.oransc.rappmanager.sme.service;
  21
  22 import static org.junit.jupiter.api.Assertions.assertEquals;
  23 import static org.junit.jupiter.api.Assertions.assertFalse;
  24 import static org.junit.jupiter.api.Assertions.assertNull;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
  27 import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
  28 import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
  29
  30 import com.fasterxml.jackson.core.JsonProcessingException;
  31 import com.fasterxml.jackson.databind.ObjectMapper;
  32 import com.oransc.rappmanager.models.cache.RappCacheService;
  33 import com.oransc.rappmanager.models.configuration.RappsEnvironmentConfiguration;
  34 import com.oransc.rappmanager.models.csar.RappCsarConfigurationHandler;
  35 import com.oransc.rappmanager.models.rapp.Rapp;
  36 import com.oransc.rappmanager.models.rapp.RappState;
  37 import com.oransc.rappmanager.models.rappinstance.RappInstance;
  38 import com.oransc.rappmanager.models.rappinstance.RappSMEInstance;
  39 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachine;
  40 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachineConfig;
  41 import com.oransc.rappmanager.sme.configuration.SmeConfiguration;
  42 import com.oransc.rappmanager.sme.invoker.data.APIInvokerEnrolmentDetails;
  43 import com.oransc.rappmanager.sme.provider.data.APIProviderEnrolmentDetails;
  44 import com.oransc.rappmanager.sme.provider.data.APIProviderFunctionDetails;
  45 import com.oransc.rappmanager.sme.provider.data.ApiProviderFuncRole;
  46 import com.oransc.rappmanager.sme.publishservice.data.AefProfile;
  47 import com.oransc.rappmanager.sme.publishservice.data.ServiceAPIDescription;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.UUID;
  51 import org.junit.jupiter.api.BeforeAll;
  52 import org.junit.jupiter.api.BeforeEach;
  53 import org.junit.jupiter.api.Test;
  54 import org.junit.jupiter.api.TestInstance;
  55 import org.springframework.beans.factory.annotation.Autowired;
  56 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
  57 import org.springframework.boot.test.context.SpringBootTest;
  58 import org.springframework.boot.test.mock.mockito.SpyBean;
  59 import org.springframework.http.HttpMethod;
  60 import org.springframework.http.HttpStatus;
  61 import org.springframework.http.MediaType;
  62 import org.springframework.test.web.client.ExpectedCount;
  63 import org.springframework.test.web.client.MockRestServiceServer;
  64 import org.springframework.web.client.RestTemplate;
  65
  66 @SpringBootTest(classes = {SmeConfiguration.class, SmeDeployer.class, BeanTestConfiguration.class,
  67         RappsEnvironmentConfiguration.class, RappCsarConfigurationHandler.class, RappCacheService.class,
  68         RappInstanceStateMachineConfig.class, RappInstanceStateMachine.class})
  69 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
  70 @AutoConfigureMockMvc
  71 class SmeDeployerTest {
  72
  73     MockRestServiceServer mockServer;
  74     @Autowired
  75     @SpyBean
  76     SmeDeployer smeDeployer;
  77     @Autowired
  78     RestTemplate restTemplate;
  79     @Autowired
  80     SmeConfiguration smeConfiguration;
  81     String validCsarFileLocation = "src/test/resources/";
  82     @Autowired
  83     RappInstanceStateMachine rappInstanceStateMachine;
  84     @Autowired
  85     ObjectMapper objectMapper;
  86     private final String validRappFile = "valid-rapp-package.csar";
  87     String URI_PROVIDER_REGISTRATIONS, URI_PROVIDER_REGISTRATION, URI_PUBLISH_APIS, URI_PUBLISH_API, URI_INVOKERS,
  88             URI_INVOKER;
  89
  90     @BeforeAll
  91     void initSmeUri() {
  92         URI_PROVIDER_REGISTRATIONS =
  93                 smeConfiguration.getBaseUrl() + smeConfiguration.getProviderBasePath() + "registrations";
  94         URI_PROVIDER_REGISTRATION =
  95                 smeConfiguration.getBaseUrl() + smeConfiguration.getProviderBasePath() + "registrations/%s";
  96         URI_PUBLISH_APIS = smeConfiguration.getBaseUrl() + smeConfiguration.getPublishApiBasePath() + "%s/service-apis";
  97         URI_PUBLISH_API =
  98                 smeConfiguration.getBaseUrl() + smeConfiguration.getPublishApiBasePath() + "%s/service-apis/%s";
  99         URI_INVOKERS = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers";
 100         URI_INVOKER = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers/%s";
 101     }
 102
 103     @BeforeEach
 104     public void init() {
 105         mockServer = MockRestServiceServer.createServer(restTemplate);
 106     }
 107
 108     @Test
 109     void testCreateAMF() throws JsonProcessingException {
 110         String apiProvDomId = UUID.randomUUID().toString();
 111         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails(apiProvDomId);
 112         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 113                 .andExpect(method(HttpMethod.POST)).andRespond(
 114                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 115                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 116         APIProviderEnrolmentDetails apiProviderEnrolmentResponse = smeDeployer.createAMF();
 117         mockServer.verify();
 118         assertEquals(apiProvDomId, apiProviderEnrolmentResponse.getApiProvDomId());
 119     }
 120
 121     @Test
 122     void testCreateAMFFailure() {
 123         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 124                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 125         APIProviderEnrolmentDetails apiProviderEnrolmentResponse = smeDeployer.createAMF();
 126         mockServer.verify();
 127         assertNull(apiProviderEnrolmentResponse);
 128     }
 129
 130     @Test
 131     void testDeleteAMF() throws JsonProcessingException {
 132         String apiProvDomId = UUID.randomUUID().toString();
 133         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails(apiProvDomId);
 134         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 135                 .andExpect(method(HttpMethod.POST)).andRespond(
 136                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 137                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 138         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PROVIDER_REGISTRATION, apiProvDomId)))
 139                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 140         smeDeployer.createAMF();
 141         smeDeployer.deleteAMF();
 142         mockServer.verify();
 143     }
 144
 145     @Test
 146     void testCreateProviderDomain() throws Exception {
 147         UUID rappId = UUID.randomUUID();
 148         Rapp rapp =
 149                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 150                         .state(RappState.COMMISSIONED).build();
 151         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = getProviderDomainApiEnrollmentDetails();
 152         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 153                 .andExpect(method(HttpMethod.POST)).andRespond(
 154                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 155                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 156         RappInstance rappInstance = getRappInstance();
 157         boolean createProviderDomain = smeDeployer.createProviderDomain(rapp, rappInstance);
 158         mockServer.verify();
 159         assertTrue(createProviderDomain);
 160     }
 161
 162     @Test
 163     void testCreateProviderDomainFailure() {
 164         UUID rappId = UUID.randomUUID();
 165         Rapp rapp =
 166                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 167                         .state(RappState.COMMISSIONED).build();
 168         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 169                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 170         RappInstance rappInstance = getRappInstance();
 171         boolean createProviderDomain = smeDeployer.createProviderDomain(rapp, rappInstance);
 172         mockServer.verify();
 173         assertFalse(createProviderDomain);
 174     }
 175
 176     @Test
 177     void testDeleteProviderFunc() {
 178         UUID registrationId = UUID.randomUUID();
 179         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PROVIDER_REGISTRATION, registrationId)))
 180                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 181         smeDeployer.deleteProviderFunc(String.valueOf(registrationId));
 182         mockServer.verify();
 183     }
 184
 185     @Test
 186     void testCreatePublishApi() throws Exception {
 187         UUID rappId = UUID.randomUUID();
 188         UUID apfId = UUID.randomUUID();
 189         Rapp rapp =
 190                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 191                         .state(RappState.COMMISSIONED).build();
 192         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
 193         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_APIS, apfId)))
 194                 .andExpect(method(HttpMethod.POST)).andRespond(
 195                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 196                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
 197         RappInstance rappInstance = getRappInstance();
 198         rappInstance.getSme().setApfId(String.valueOf(apfId));
 199         boolean publishApi = smeDeployer.createPublishApi(rapp, rappInstance);
 200         mockServer.verify();
 201         assertTrue(publishApi);
 202     }
 203
 204
 205     @Test
 206     void testCreatePublishApiFailure() {
 207         UUID rappId = UUID.randomUUID();
 208         UUID apfId = UUID.randomUUID();
 209         Rapp rapp =
 210                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 211                         .state(RappState.COMMISSIONED).build();
 212         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_APIS, apfId)))
 213                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 214         RappInstance rappInstance = getRappInstance();
 215         rappInstance.getSme().setApfId(String.valueOf(apfId));
 216         boolean publishApi = smeDeployer.createPublishApi(rapp, rappInstance);
 217         mockServer.verify();
 218         assertFalse(publishApi);
 219     }
 220
 221     @Test
 222     void testDeletePublishApi() {
 223         String serviceApiId = String.valueOf(UUID.randomUUID());
 224         String apfId = String.valueOf(UUID.randomUUID());
 225         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApiId)))
 226                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 227         smeDeployer.deletePublishApi(serviceApiId, apfId);
 228         mockServer.verify();
 229     }
 230
 231     @Test
 232     void testCreateInvoker() throws Exception {
 233         UUID rappId = UUID.randomUUID();
 234         Rapp rapp =
 235                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 236                         .state(RappState.COMMISSIONED).build();
 237         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
 238         mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
 239                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 240                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
 241         RappInstance rappInstance = getRappInstance();
 242         boolean createInvoker = smeDeployer.createInvoker(rapp, rappInstance);
 243         mockServer.verify();
 244         assertTrue(createInvoker);
 245     }
 246
 247     @Test
 248     void testCreateInvokerFailure() {
 249         UUID rappId = UUID.randomUUID();
 250         Rapp rapp =
 251                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 252                         .state(RappState.COMMISSIONED).build();
 253         mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST))
 254                 .andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 255         RappInstance rappInstance = getRappInstance();
 256         boolean createInvoker = smeDeployer.createInvoker(rapp, rappInstance);
 257         mockServer.verify();
 258         assertFalse(createInvoker);
 259     }
 260
 261     @Test
 262     void testDeleteInvoker() {
 263         String invokerId = String.valueOf(UUID.randomUUID());
 264         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokerId)))
 265                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 266         smeDeployer.deleteInvoker(invokerId);
 267         mockServer.verify();
 268     }
 269
 270     @Test
 271     void testDeployRappInstance() throws Exception {
 272         UUID rappId = UUID.randomUUID();
 273         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = getProviderDomainApiEnrollmentDetails();
 274         APIProviderFunctionDetails apfProviderFunctionDetails = apiProviderEnrolmentDetails.getApiProvFuncs().stream()
 275                                                                         .filter(apiProviderFunctionDetails -> apiProviderFunctionDetails.getApiProvFuncRole()
 276                                                                                                                       .equals(ApiProviderFuncRole.APF))
 277                                                                         .findFirst().get();
 278         Rapp rapp =
 279                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 280                         .state(RappState.COMMISSIONED).build();
 281         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 282                 .andExpect(method(HttpMethod.POST)).andRespond(
 283                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 284                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 285         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
 286         mockServer.expect(ExpectedCount.once(),
 287                         requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
 288                 .andExpect(method(HttpMethod.POST)).andRespond(
 289                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 290                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
 291         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
 292         mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
 293                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 294                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
 295         RappInstance rappInstance = getRappInstance();
 296         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 297         boolean deployRapp = smeDeployer.deployRappInstance(rapp, rappInstance);
 298         mockServer.verify();
 299         assertTrue(deployRapp);
 300     }
 301
 302     @Test
 303     void testDeployRappInstanceNoInvoker() throws Exception {
 304         UUID rappId = UUID.randomUUID();
 305         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = getProviderDomainApiEnrollmentDetails();
 306         APIProviderFunctionDetails apfProviderFunctionDetails = apiProviderEnrolmentDetails.getApiProvFuncs().stream()
 307                                                                         .filter(apiProviderFunctionDetails -> apiProviderFunctionDetails.getApiProvFuncRole()
 308                                                                                                                       .equals(ApiProviderFuncRole.APF))
 309                                                                         .findFirst().get();
 310         Rapp rapp =
 311                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 312                         .state(RappState.COMMISSIONED).build();
 313         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 314                 .andExpect(method(HttpMethod.POST)).andRespond(
 315                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 316                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 317         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
 318         mockServer.expect(ExpectedCount.once(),
 319                         requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
 320                 .andExpect(method(HttpMethod.POST)).andRespond(
 321                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 322                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
 323         RappInstance rappInstance = getRappInstance();
 324         rappInstance.getSme().setInvokers(null);
 325         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 326         boolean deployRapp = smeDeployer.deployRappInstance(rapp, rappInstance);
 327         mockServer.verify();
 328         assertTrue(deployRapp);
 329     }
 330
 331     @Test
 332     void testDeployRappInstanceNoProvider() throws Exception {
 333         UUID rappId = UUID.randomUUID();
 334         Rapp rapp =
 335                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 336                         .state(RappState.COMMISSIONED).build();
 337         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
 338         mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
 339                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 340                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
 341         RappInstance rappInstance = getRappInstance();
 342         rappInstance.getSme().setProviderFunction(null);
 343         rappInstance.getSme().setServiceApis(null);
 344         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 345         boolean deployRapp = smeDeployer.deployRappInstance(rapp, rappInstance);
 346         mockServer.verify();
 347         assertTrue(deployRapp);
 348     }
 349
 350     @Test
 351     void testDeployRappInstanceWithoutSme() {
 352         UUID rappId = UUID.randomUUID();
 353         Rapp rapp =
 354                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 355                         .state(RappState.PRIMED).build();
 356         RappInstance rappInstance = getRappInstance();
 357         rappInstance.setSme(null);
 358         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 359         assertTrue(smeDeployer.deployRappInstance(rapp, rappInstance));
 360     }
 361
 362     @Test
 363     void testDeployRappFailure() throws Exception {
 364         UUID rappId = UUID.randomUUID();
 365         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = getProviderDomainApiEnrollmentDetails();
 366         APIProviderFunctionDetails apfProviderFunctionDetails = apiProviderEnrolmentDetails.getApiProvFuncs().stream()
 367                                                                         .filter(apiProviderFunctionDetails -> apiProviderFunctionDetails.getApiProvFuncRole()
 368                                                                                                                       .equals(ApiProviderFuncRole.APF))
 369                                                                         .findFirst().get();
 370         Rapp rapp =
 371                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
 372                         .state(RappState.COMMISSIONED).build();
 373         mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
 374                 .andExpect(method(HttpMethod.POST)).andRespond(
 375                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 376                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
 377         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
 378         mockServer.expect(ExpectedCount.once(),
 379                         requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
 380                 .andExpect(method(HttpMethod.POST)).andRespond(
 381                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
 382                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
 383         mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST))
 384                 .andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 385         RappInstance rappInstance = getRappInstance();
 386         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 387         boolean deployRapp = smeDeployer.deployRappInstance(rapp, rappInstance);
 388         mockServer.verify();
 389         assertFalse(deployRapp);
 390     }
 391
 392     @Test
 393     void testUndeployRappInstance() {
 394         UUID rappId = UUID.randomUUID();
 395         UUID apfId = UUID.randomUUID();
 396         List<String> invokers = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 397         List<String> serviceApis = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 398         Map<String, String> providerFuncs = Map.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()),
 399                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 400         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
 401                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
 402         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
 403                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 404         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
 405                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 406         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
 407                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 408         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
 409                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 410         mockServer.expect(ExpectedCount.once(),
 411                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
 412                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 413         mockServer.expect(ExpectedCount.once(),
 414                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
 415                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 416         RappInstance rappInstance = getRappInstance();
 417         rappInstance.getSme().setApfId(String.valueOf(apfId));
 418         rappInstance.getSme().setProviderFunctionIds(providerFuncs.values().stream().toList());
 419         rappInstance.getSme().setServiceApiIds(serviceApis);
 420         rappInstance.getSme().setInvokerIds(invokers);
 421         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 422         boolean undeployRapp = smeDeployer.undeployRappInstance(rapp, rappInstance);
 423         mockServer.verify();
 424         assertTrue(undeployRapp);
 425     }
 426
 427     @Test
 428     void testUndeployRappInstanceNoInvokers() {
 429         UUID rappId = UUID.randomUUID();
 430         UUID apfId = UUID.randomUUID();
 431         List<String> serviceApis = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 432         Map<String, String> providerFuncs = Map.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()),
 433                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 434         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
 435                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
 436         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
 437                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 438         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
 439                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 440         mockServer.expect(ExpectedCount.once(),
 441                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
 442                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 443         mockServer.expect(ExpectedCount.once(),
 444                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
 445                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 446         RappInstance rappInstance = getRappInstance();
 447         rappInstance.getSme().setApfId(String.valueOf(apfId));
 448         rappInstance.getSme().setProviderFunctionIds(providerFuncs.values().stream().toList());
 449         rappInstance.getSme().setServiceApiIds(serviceApis);
 450         rappInstance.getSme().setInvokerIds(null);
 451         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 452         boolean undeployRapp = smeDeployer.undeployRappInstance(rapp, rappInstance);
 453         mockServer.verify();
 454         assertTrue(undeployRapp);
 455     }
 456
 457     @Test
 458     void testUndeployRappInstanceNoProviders() {
 459         UUID rappId = UUID.randomUUID();
 460         UUID apfId = UUID.randomUUID();
 461         List<String> invokers = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 462         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
 463                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
 464         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
 465                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 466         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
 467                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 468         RappInstance rappInstance = getRappInstance();
 469         rappInstance.getSme().setApfId(String.valueOf(apfId));
 470         rappInstance.getSme().setProviderFunctionIds(null);
 471         rappInstance.getSme().setServiceApiIds(null);
 472         rappInstance.getSme().setInvokerIds(invokers);
 473         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 474         boolean undeployRapp = smeDeployer.undeployRappInstance(rapp, rappInstance);
 475         mockServer.verify();
 476         assertTrue(undeployRapp);
 477     }
 478
 479     @Test
 480     void testUndeployRappInstanceWithoutSme() {
 481         UUID rappId = UUID.randomUUID();
 482         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
 483                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
 484         RappInstance rappInstance = getRappInstance();
 485         rappInstance.setSme(null);
 486         assertTrue(smeDeployer.undeployRappInstance(rapp, rappInstance));
 487     }
 488
 489     @Test
 490     void testUndeployRappInstanceFailure() {
 491         UUID rappId = UUID.randomUUID();
 492         UUID apfId = UUID.randomUUID();
 493         List<String> invokers = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 494         List<String> serviceApis = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 495         Map<String, String> providerFuncs = Map.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()),
 496                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
 497         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
 498                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
 499         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
 500                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 501         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
 502                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 503         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
 504                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 505         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
 506                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 507         mockServer.expect(ExpectedCount.once(),
 508                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
 509                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 510         mockServer.expect(ExpectedCount.once(),
 511                         requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
 512                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 513         RappInstance rappInstance = getRappInstance();
 514         rappInstance.getSme().setApfId(String.valueOf(apfId));
 515         rappInstance.getSme().setProviderFunctionIds(providerFuncs.values().stream().toList());
 516         rappInstance.getSme().setServiceApiIds(serviceApis);
 517         rappInstance.getSme().setInvokerIds(invokers);
 518         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 519         boolean undeployRapp = smeDeployer.undeployRappInstance(rapp, rappInstance);
 520         mockServer.verify();
 521         assertFalse(undeployRapp);
 522     }
 523
 524     @Test
 525     void testPrimingAndDeprimingDoesNothing() {
 526         assertTrue(smeDeployer.primeRapp(null));
 527         assertTrue(smeDeployer.deprimeRapp(null));
 528     }
 529
 530     RappInstance getRappInstance() {
 531         RappSMEInstance rappSMEInstance = new RappSMEInstance();
 532         rappSMEInstance.setInvokers("invoker-app1");
 533         rappSMEInstance.setServiceApis("api-set-1");
 534         rappSMEInstance.setAefId("TEST_AEF_ID");
 535         rappSMEInstance.setApfId(String.valueOf(UUID.randomUUID()));
 536         rappSMEInstance.setProviderFunction("provider-function-1");
 537         RappInstance rappInstance = new RappInstance();
 538         rappInstance.setSme(rappSMEInstance);
 539         return rappInstance;
 540     }
 541
 542     APIProviderEnrolmentDetails getProviderDomainApiEnrollmentDetails() {
 543         APIProviderEnrolmentDetails apiProviderEnrolmentDetails =
 544                 new APIProviderEnrolmentDetails(UUID.randomUUID().toString());
 545         APIProviderFunctionDetails apiProviderFunctionDetailsAEF = new APIProviderFunctionDetails();
 546         apiProviderFunctionDetailsAEF.setApiProvFuncInfo("AEF");
 547         apiProviderFunctionDetailsAEF.setApiProvFuncRole(ApiProviderFuncRole.AEF);
 548         apiProviderFunctionDetailsAEF.setApiProvFuncId(String.valueOf(UUID.randomUUID()));
 549         APIProviderFunctionDetails apiProviderFunctionDetailsAPF = new APIProviderFunctionDetails();
 550         apiProviderFunctionDetailsAPF.setApiProvFuncInfo("APF");
 551         apiProviderFunctionDetailsAPF.setApiProvFuncRole(ApiProviderFuncRole.APF);
 552         apiProviderFunctionDetailsAPF.setApiProvFuncId(String.valueOf(UUID.randomUUID()));
 553         apiProviderEnrolmentDetails.setApiProvFuncs(
 554                 List.of(apiProviderFunctionDetailsAEF, apiProviderFunctionDetailsAPF));
 555         return apiProviderEnrolmentDetails;
 556     }
 557
 558
 559     ServiceAPIDescription getServiceApiDescription() {
 560         ServiceAPIDescription serviceAPIDescription = new ServiceAPIDescription();
 561         serviceAPIDescription.setApiId(String.valueOf(UUID.randomUUID()));
 562         AefProfile aefProfile = new AefProfile();
 563         aefProfile.setAefId(String.valueOf(UUID.randomUUID()));
 564         serviceAPIDescription.setAefProfiles(List.of(aefProfile));
 565         return serviceAPIDescription;
 566     }
 567
 568     APIInvokerEnrolmentDetails getApiInvokerEnrollmentDetails() {
 569         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails =
 570                 new APIInvokerEnrolmentDetails(String.valueOf(UUID.randomUUID()));
 571         com.oransc.rappmanager.sme.invoker.data.ServiceAPIDescription serviceAPIDescription =
 572                 new com.oransc.rappmanager.sme.invoker.data.ServiceAPIDescription();
 573         serviceAPIDescription.setApiId(String.valueOf(UUID.randomUUID()));
 574         apiInvokerEnrolmentDetails.setApiList(List.of(serviceAPIDescription));
 575         return apiInvokerEnrolmentDetails;
 576     }
 577 }