import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.oransc.rappmanager.models.exception.RappHandlerException;
+import com.google.gson.JsonSyntaxException;
+import com.oransc.rappmanager.models.configuration.RappsEnvironmentConfiguration;
import com.oransc.rappmanager.models.rapp.Rapp;
import com.oransc.rappmanager.models.rapp.RappResources;
import com.oransc.rappmanager.models.rappinstance.RappACMInstance;
import com.oransc.rappmanager.models.rappinstance.RappDMEInstance;
+import com.oransc.rappmanager.models.rappinstance.RappInstance;
import com.oransc.rappmanager.models.rappinstance.RappSMEInstance;
import java.io.ByteArrayOutputStream;
import java.io.File;
-import java.io.FileInputStream;
import java.io.IOException;
import java.util.Set;
import java.util.UUID;
-import java.util.stream.Stream;
-import org.apache.http.entity.ContentType;
+import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream;
+import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.SpyBean;
-import org.springframework.http.HttpStatus;
-import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.context.ContextConfiguration;
-import org.springframework.web.multipart.MultipartFile;
@SpringBootTest
-@ContextConfiguration(classes = {ObjectMapper.class, RappCsarConfigurationHandler.class})
+@EnableConfigurationProperties
+@ContextConfiguration(
+ classes = {ObjectMapper.class, RappsEnvironmentConfiguration.class, RappCsarConfigurationHandler.class})
class RappCsarConfigurationHandlerTest {
@SpyBean
RappCsarConfigurationHandler rappCsarConfigurationHandler;
+ @Autowired
+ RappsEnvironmentConfiguration rappsEnvironmentConfiguration;
+ @Autowired
+ ObjectMapper objectMapper;
String validCsarFileLocation = "src/test/resources/";
-
private final String validRappFile = "valid-rapp-package.csar";
- private final String invalidRappFile = "invalid-rapp-package.csar";
-
- @Test
- void testCsarPackageValidationSuccess() throws IOException {
- String rappCsarPath = validCsarFileLocation + File.separator + validRappFile;
- MultipartFile multipartFile =
- new MockMultipartFile(rappCsarPath, rappCsarPath, ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPath));
- assertEquals(Boolean.TRUE, rappCsarConfigurationHandler.isValidRappPackage(multipartFile));
- }
-
- @ParameterizedTest
- @MethodSource("getInvalidCsarPackage")
- void testCsarPackageValidationFailure(MultipartFile multipartFile) {
- System.out.println(multipartFile.getOriginalFilename());
- RappHandlerException exception = assertThrows(RappHandlerException.class,
- () -> rappCsarConfigurationHandler.isValidRappPackage(multipartFile));
- assertEquals(HttpStatus.BAD_REQUEST, exception.getStatusCode());
- }
-
-
- private static Stream<Arguments> getInvalidCsarPackage() throws IOException {
- String validCsarFileLocation = "src/test/resources";
- String rappCsarPath = validCsarFileLocation + File.separator + "invalid-rapp-package.csar";
- MultipartFile multipartFile =
- new MockMultipartFile(rappCsarPath, rappCsarPath, ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPath));
- String rappCsarPathNoTosca = validCsarFileLocation + File.separator + "invalid-rapp-package-no-tosca.csar";
- MultipartFile multipartFileNoTosca = new MockMultipartFile(rappCsarPathNoTosca, rappCsarPathNoTosca,
- ContentType.MULTIPART_FORM_DATA.getMimeType(), new FileInputStream(rappCsarPathNoTosca));
- String rappCsarPathNoAsdYaml = validCsarFileLocation + File.separator + "invalid-rapp-package-no-asd-yaml.csar";
- MultipartFile multipartFileNoAsdYaml = new MockMultipartFile(rappCsarPathNoAsdYaml, rappCsarPathNoAsdYaml,
- ContentType.MULTIPART_FORM_DATA.getMimeType(), new FileInputStream(rappCsarPathNoAsdYaml));
- String rappCsarPathMissingArtifact =
- validCsarFileLocation + File.separator + "invalid-rapp-package-missing-artifact.csar";
- MultipartFile multipartFileMissingArtifact =
- new MockMultipartFile(rappCsarPathMissingArtifact, rappCsarPathMissingArtifact,
- ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPathMissingArtifact));
- String rappCsarPathNoComposition =
- validCsarFileLocation + File.separator + "invalid-rapp-package-no-acm-composition.csar";
- MultipartFile multipartFileNoComposition =
- new MockMultipartFile(rappCsarPathNoComposition, rappCsarPathNoComposition,
- ContentType.MULTIPART_FORM_DATA.getMimeType(), new FileInputStream(rappCsarPathNoComposition));
- return Stream.of(Arguments.of(multipartFile), Arguments.of(multipartFileNoTosca),
- Arguments.of(multipartFileNoAsdYaml), Arguments.of(multipartFileMissingArtifact),
- Arguments.of(multipartFileNoComposition));
- }
-
- @Test
- void testCsarPackageValidationFailureWithoutOrginalName() {
- MultipartFile multipartFile = mock(MultipartFile.class);
- assertEquals(Boolean.FALSE, rappCsarConfigurationHandler.isValidRappPackage(multipartFile));
- }
-
- @Test
- void testInvalidCsarFileExist() {
- MultipartFile multipartFile = mock(MultipartFile.class);
- RappHandlerException exception = assertThrows(RappHandlerException.class,
- () -> rappCsarConfigurationHandler.isFileExistsInCsar(multipartFile, "INVALID_LOCATION"));
- assertEquals(HttpStatus.BAD_REQUEST, exception.getStatusCode());
- }
-
- @Test
- void testCsarContainsValidAsdFile() throws IOException {
- String rappCsarPath = validCsarFileLocation + File.separator + validRappFile;
- MultipartFile multipartFile =
- new MockMultipartFile(rappCsarPath, rappCsarPath, ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPath));
- assertTrue(rappCsarConfigurationHandler.containsValidArtifactDefinition(multipartFile));
- }
-
- @Test
- void testCsarContainsValidAsdFileFailure() throws IOException {
- String rappCsarPath = validCsarFileLocation + File.separator + invalidRappFile;
- MultipartFile multipartFile =
- new MockMultipartFile(rappCsarPath, rappCsarPath, ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPath));
- RappHandlerException exception = assertThrows(RappHandlerException.class,
- () -> rappCsarConfigurationHandler.containsValidArtifactDefinition(multipartFile));
- assertEquals(HttpStatus.BAD_REQUEST, exception.getStatusCode());
- }
-
- @Test
- void testCsarNoAsdFailure() {
- MultipartFile multipartFile = mock(MultipartFile.class);
- RappHandlerException exception = assertThrows(RappHandlerException.class,
- () -> rappCsarConfigurationHandler.containsValidArtifactDefinition(multipartFile));
- assertEquals(HttpStatus.BAD_REQUEST, exception.getStatusCode());
- }
-
- @Test
- void testCsarAsdContentInvalidFailure() throws IOException {
- String rappCsarPath = validCsarFileLocation + File.separator + validRappFile;
- MultipartFile multipartFile =
- new MockMultipartFile(rappCsarPath, rappCsarPath, ContentType.MULTIPART_FORM_DATA.getMimeType(),
- new FileInputStream(rappCsarPath));
- String invalidJson = "{asasdasd";
- ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
- byteArrayOutputStream.write(invalidJson.getBytes(), 0, invalidJson.getBytes().length);
- doCallRealMethod().doReturn(byteArrayOutputStream).when(rappCsarConfigurationHandler)
- .getFileFromCsar(any(MultipartFile.class), any());
- RappHandlerException exception = assertThrows(RappHandlerException.class,
- () -> rappCsarConfigurationHandler.containsValidArtifactDefinition(multipartFile));
- assertEquals(HttpStatus.BAD_REQUEST, exception.getStatusCode());
- }
+ private final String invalidRappNoAsdFile = "invalid-rapp-package-no-asd-yaml.csar";
- @Test
- void testgetFileFromCsarFailure() throws IOException {
- MultipartFile multipartFile = mock(MultipartFile.class);
- when(multipartFile.getInputStream()).thenThrow(new IOException());
- assertThat(rappCsarConfigurationHandler.getFileFromCsar(multipartFile, null).size()).isZero();
- }
+ private final String invalidRappEmptyAsdFile = "invalid-rapp-package-empty-asd-yaml.csar";
@Test
- void testCsarInstantiationPayload() throws JSONException {
+ void testCsarInstantiationPayload() throws JSONException, JsonProcessingException {
Rapp rapp = Rapp.builder().name("").packageName(validRappFile).packageLocation(validCsarFileLocation).build();
UUID compositionId = UUID.randomUUID();
- RappACMInstance rappACMInstance = new RappACMInstance();
- rappACMInstance.setInstance("kserve-instance");
- JSONObject jsonObject = new JSONObject(
- rappCsarConfigurationHandler.getInstantiationPayload(rapp, rappACMInstance, compositionId));
- assertEquals(jsonObject.get("compositionId"), String.valueOf(compositionId));
+ RappInstance rappInstance = new RappInstance();
+ RappACMInstance rappKserveACMInstance = new RappACMInstance();
+ rappKserveACMInstance.setInstance("kserve-instance");
+ rappInstance.setAcm(rappKserveACMInstance);
+ JSONObject kserveInstanceJsonObject =
+ new JSONObject(rappCsarConfigurationHandler.getInstantiationPayload(rapp, rappInstance, compositionId));
+ assertEquals(kserveInstanceJsonObject.get("compositionId"), String.valueOf(compositionId));
+ RappACMInstance rappK8sACMInstance = new RappACMInstance();
+ rappK8sACMInstance.setInstance("k8s-instance");
+ rappInstance.setAcm(rappK8sACMInstance);
+ JsonNode jsonNode = objectMapper.readTree(
+ rappCsarConfigurationHandler.getInstantiationPayload(rapp, rappInstance, compositionId));
+ assertEquals(jsonNode.get("compositionId").asText(), String.valueOf(compositionId));
+ JsonNode overrideParamsNode = jsonNode.at("/elements").elements().next().at("/properties/chart/overrideParams");
+ System.out.println(overrideParamsNode);
+ assertEquals(overrideParamsNode.get("appId").asText(), rappInstance.getRappInstanceId().toString());
+ assertEquals(overrideParamsNode.get("smeDiscoveryEndpoint").asText(),
+ rappsEnvironmentConfiguration.getSmeDiscoveryEndpoint());
}
@Test
assertThat(fileByteArray.size()).isZero();
}
+ @Test
+ void testInvalidZipStreamGetFromCsar() throws IOException {
+ ZipArchiveInputStream zipArchiveInputStream = mock(ZipArchiveInputStream.class);
+ doThrow(new IOException()).when(zipArchiveInputStream).getNextEntry();
+ ByteArrayOutputStream fileByteArray = rappCsarConfigurationHandler.getFileFromCsar(zipArchiveInputStream, null);
+ assertThat(fileByteArray.size()).isZero();
+ }
+
@Test
void testListResources() {
UUID rappId = UUID.randomUUID();
assertThat(rappResources).isNotNull();
assertNotNull(rappResources.getAcm().getCompositionDefinitions());
assertThat(rappResources.getAcm().getCompositionInstances()).hasSize(4);
- assertThat(rappResources.getSme().getProviderFunctions()).hasSize(4);
+ assertThat(rappResources.getSme().getProviderFunctions()).hasSize(3);
assertThat(rappResources.getSme().getServiceApis()).hasSize(2);
assertThat(rappResources.getSme().getInvokers()).hasSize(2);
assertThat(rappResources.getDme().getProducerInfoTypes()).hasSize(2);
void testGetSmeInvokerPayload() {
UUID rappId = UUID.randomUUID();
RappSMEInstance rappSMEInstance = new RappSMEInstance();
- rappSMEInstance.setServiceApis("invoker-app1");
+ rappSMEInstance.setInvokers("invoker-app1");
+ RappInstance rappInstance = new RappInstance();
+ rappInstance.setSme(rappSMEInstance);
Rapp rapp =
Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
.build();
- String smeProviderDomainPayload = rappCsarConfigurationHandler.getSmeInvokerPayload(rapp, rappSMEInstance);
- assertNotNull(smeProviderDomainPayload);
+ JSONArray smeInvokerPayload =
+ new JSONArray(rappCsarConfigurationHandler.getSmeInvokerPayload(rapp, rappInstance));
+ assertNotNull(smeInvokerPayload);
+ assertEquals(smeInvokerPayload.getJSONObject(0).getString("apiInvokerInformation"),
+ rappInstance.getRappInstanceId().toString());
}
@Test
assertNotNull(dmeInfoConsumerPayload);
}
+ @Test
+ void testGetAsdMetadata() {
+ Rapp rapp = Rapp.builder().name("").packageName(validRappFile).packageLocation(validCsarFileLocation).build();
+ AsdMetadata asdMetadata = rappCsarConfigurationHandler.getAsdMetadata(rapp);
+ assertEquals("123e4567-e89b-12d3-a456-426614174000", asdMetadata.getDescriptorId());
+ assertEquals("040eff2a-eb1a-4aff-bd46-37ce38092985", asdMetadata.getDescriptorInvariantId());
+ assertEquals(2, asdMetadata.getDeploymentItems().size());
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {invalidRappNoAsdFile, invalidRappEmptyAsdFile})
+ void testGetAsdMetadataNoAsd(String packageName) {
+ Rapp rapp = Rapp.builder().name("").packageName(packageName).packageLocation(validCsarFileLocation).build();
+ assertThat(rappCsarConfigurationHandler.getAsdMetadata(rapp)).isNotNull();
+ }
+
+ @Test
+ void testGetAsdMetadataException() throws JsonProcessingException {
+ Rapp rapp = Rapp.builder().name("").packageName(validRappFile).packageLocation(validCsarFileLocation).build();
+ doThrow(new JsonSyntaxException("")).when(rappCsarConfigurationHandler).getAsdContentNode(any());
+ assertNull(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDescriptorId());
+ assertNull(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDescriptorInvariantId());
+ assertThat(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDeploymentItems()).isNull();
+ }
+
+ @Test
+ void testGetAsdMetadataNullAsdContent() throws JsonProcessingException {
+ Rapp rapp = Rapp.builder().name("").packageName(validRappFile).packageLocation(validCsarFileLocation).build();
+ doReturn(null).when(rappCsarConfigurationHandler).getAsdContentNode(any());
+ assertNull(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDescriptorId());
+ assertNull(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDescriptorInvariantId());
+ assertThat(rappCsarConfigurationHandler.getAsdMetadata(rapp).getDeploymentItems()).isNull();
+ }
+
+ @Test
+ void testGetArtifactPayload() {
+ Rapp rapp = Rapp.builder().name("").packageName(validRappFile).packageLocation(validCsarFileLocation).build();
+ assertNotNull(rappCsarConfigurationHandler.getArtifactPayload(rapp,
+ "Artifacts/Deployment/HELM/ransliceassurance-1.0.0.tgz"));
+
+ }
}
Code Review / nonrtric / plt / rappmanager.git / blobdiff