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
10 * http://www.apache.org/licenses/LICENSE-2.0
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========================================================================
20 package com.oransc.rappmanager.sme.service;
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;
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;
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;
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)
71 class SmeDeployerTest {
73 MockRestServiceServer mockServer;
76 SmeDeployer smeDeployer;
78 RestTemplate restTemplate;
80 SmeConfiguration smeConfiguration;
81 String validCsarFileLocation = "src/test/resources/";
83 RappInstanceStateMachine rappInstanceStateMachine;
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,
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";
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";
105 mockServer = MockRestServiceServer.createServer(restTemplate);
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();
118 assertEquals(apiProvDomId, apiProviderEnrolmentResponse.getApiProvDomId());
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();
127 assertNull(apiProviderEnrolmentResponse);
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();
146 void testCreateProviderDomain() throws Exception {
147 UUID rappId = UUID.randomUUID();
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);
159 assertTrue(createProviderDomain);
163 void testCreateProviderDomainFailure() {
164 UUID rappId = UUID.randomUUID();
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);
173 assertFalse(createProviderDomain);
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));
186 void testCreatePublishApi() throws Exception {
187 UUID rappId = UUID.randomUUID();
188 UUID apfId = UUID.randomUUID();
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);
201 assertTrue(publishApi);
206 void testCreatePublishApiFailure() {
207 UUID rappId = UUID.randomUUID();
208 UUID apfId = UUID.randomUUID();
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);
218 assertFalse(publishApi);
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);
232 void testCreateInvoker() throws Exception {
233 UUID rappId = UUID.randomUUID();
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);
244 assertTrue(createInvoker);
248 void testCreateInvokerFailure() {
249 UUID rappId = UUID.randomUUID();
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);
258 assertFalse(createInvoker);
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);
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))
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);
299 assertTrue(deployRapp);
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))
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);
328 assertTrue(deployRapp);
332 void testDeployRappInstanceNoProvider() throws Exception {
333 UUID rappId = UUID.randomUUID();
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);
347 assertTrue(deployRapp);
351 void testDeployRappInstanceWithoutSme() {
352 UUID rappId = UUID.randomUUID();
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));
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))
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);
389 assertFalse(deployRapp);
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);
424 assertTrue(undeployRapp);
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);
454 assertTrue(undeployRapp);
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);
476 assertTrue(undeployRapp);
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));
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);
521 assertFalse(undeployRapp);
525 void testPrimingAndDeprimingDoesNothing() {
526 assertTrue(smeDeployer.primeRapp(null));
527 assertTrue(smeDeployer.deprimeRapp(null));
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);
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;
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;
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;