openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidatorTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications copyright (c) 2020 Nokia
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation;
  24
  25 import static org.hamcrest.MatcherAssert.assertThat;
  26 import static org.hamcrest.Matchers.anEmptyMap;
  27 import static org.hamcrest.Matchers.hasSize;
  28 import static org.hamcrest.Matchers.is;
  29 import static org.junit.Assert.assertEquals;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.mockito.ArgumentMatchers.any;
  32 import static org.mockito.Mockito.mock;
  33 import static org.mockito.Mockito.when;
  34 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_PM_DICTIONARY;
  35 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_SW_INFORMATION;
  36 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_VES_EVENTS;
  37 import static org.openecomp.sdc.be.test.util.TestResourcesHandler.getResourceBytesOrFail;
  38 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.ATTRIBUTE_VALUE_SEPARATOR;
  39 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_ARCHIVE_VERSION;
  40 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_NAME;
  41 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_RELEASE_DATE_TIME;
  42 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PRODUCT_NAME;
  43 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PROVIDER_ID;
  44 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_RELEASE_DATE_TIME;
  45 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.CREATED_BY_ENTRY;
  46 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.CSAR_VERSION_ENTRY;
  47 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ENTRY_DEFINITIONS;
  48 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_CERTIFICATE;
  49 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_CHANGE_LOG;
  50 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_LICENSES;
  51 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_MANIFEST;
  52 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_TESTS;
  53 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.TOSCA_META_FILE_VERSION_ENTRY;
  54 import static org.openecomp.sdc.tosca.csar.ToscaMetadataFileInfo.TOSCA_META_PATH_FILE_NAME;
  55 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.EMPTY_YAML_FILE_PATH;
  56 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.INVALID_YAML_FILE_PATH;
  57 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_FILE_PATH;
  58 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_IMPORT_FILE_PATH;
  59 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_SOURCE;
  60 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_CHANGELOG_FILEPATH;
  61 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_DEFINITION_FILEPATH;
  62 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_MANIFEST_FILEPATH;
  63
  64 import java.io.IOException;
  65 import java.nio.charset.StandardCharsets;
  66 import java.util.*;
  67 import java.util.function.Predicate;
  68 import java.util.stream.Collectors;
  69 import java.util.stream.Stream;
  70 import org.apache.commons.collections.CollectionUtils;
  71 import org.junit.jupiter.api.BeforeEach;
  72 import org.junit.jupiter.api.Test;
  73 import org.openecomp.sdc.common.errors.Messages;
  74 import org.openecomp.sdc.common.utils.SdcCommon;
  75 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  76 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  77 import org.openecomp.sdc.tosca.csar.ManifestTokenType;
  78 import org.openecomp.sdc.vendorsoftwareproduct.impl.onboarding.OnboardingPackageContentHandler;
  79 import org.openecomp.sdc.vendorsoftwareproduct.security.SecurityManager;
  80 import org.openecomp.sdc.vendorsoftwareproduct.security.SecurityManagerException;
  81
  82 public class SOL004MetaDirectoryValidatorTest {
  83
  84     private static int MANIFEST_DEFINITION_ERROR_COUNT = 1;
  85
  86     protected SOL004MetaDirectoryValidator sol004MetaDirectoryValidator;
  87     protected OnboardingPackageContentHandler handler;
  88     protected StringBuilder metaFileBuilder;
  89
  90     @BeforeEach
  91     public void setUp() {
  92         sol004MetaDirectoryValidator = getSOL004MetaDirectoryValidator();
  93         handler = new OnboardingPackageContentHandler();
  94         metaFileBuilder = getMetaFileBuilder();
  95     }
  96
  97     protected SOL004MetaDirectoryValidator getSOL004MetaDirectoryValidator() {
  98         return new SOL004MetaDirectoryValidator();
  99     }
 100
 101     protected SOL004MetaDirectoryValidator getSol004WithSecurity(SecurityManager securityManagerMock) {
 102         return new SOL004MetaDirectoryValidator(securityManagerMock);
 103     }
 104
 105     protected StringBuilder getMetaFileBuilder() {
 106         return new StringBuilder()
 107         .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 108             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 109         .append(CSAR_VERSION_ENTRY.getName())
 110             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 111         .append(CREATED_BY_ENTRY.getName())
 112             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 113         .append(ENTRY_DEFINITIONS.getName())
 114             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 115         .append(ETSI_ENTRY_MANIFEST.getName())
 116             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_MANIFEST_FILEPATH).append("\n")
 117         .append(ETSI_ENTRY_CHANGE_LOG.getName())
 118             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 119     }
 120
 121     protected ManifestBuilder getPnfManifestSampleBuilder() {
 122         return new ManifestBuilder()
 123             .withMetaData(PNFD_NAME.getToken(), "myPnf")
 124             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "ACME")
 125             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 126             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 127     }
 128
 129     protected ManifestBuilder getVnfManifestSampleBuilder() {
 130         return new ManifestBuilder()
 131             .withMetaData(ManifestTokenType.VNF_PRODUCT_NAME.getToken(), "RadioNode")
 132             .withMetaData(ManifestTokenType.VNF_PROVIDER_ID.getToken(), "ACME")
 133             .withMetaData(ManifestTokenType.VNF_PACKAGE_VERSION.getToken(), "1.0")
 134             .withMetaData(ManifestTokenType.VNF_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 135     }
 136
 137     /**
 138      * ETSI Version 2.7.1 below contains one Definition File reference
 139      * ETSI Version 2.7.1 onwards contains two possible Definition File reference
 140      */
 141     protected int getManifestDefinitionErrorCount() {
 142         return MANIFEST_DEFINITION_ERROR_COUNT;
 143     }
 144
 145     @Test
 146     public void testGivenTOSCAMetaFile_whenEntryHasNoValue_thenErrorIsReturned() {
 147         final String metaFileWithInvalidEntry = "TOSCA-Meta-File-Version: \n" +
 148                 "Entry-Definitions: " + TOSCA_DEFINITION_FILEPATH;
 149
 150         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileWithInvalidEntry.getBytes(StandardCharsets.UTF_8));
 151         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 152
 153         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 154         assertExpectedErrors("TOSCA Meta file with no entries", errors, 1);
 155     }
 156
 157     @Test
 158     public void testGivenTOSCAMeta_withAllSupportedEntries_thenNoErrorsReturned() {
 159
 160         final String entryTestFilePath = "Files/Tests";
 161         final String entryLicenseFilePath = "Files/Licenses";
 162
 163         handler.addFolder("Files/Tests/");
 164         handler.addFolder("Files/Licenses/");
 165         metaFileBuilder
 166                 .append(ETSI_ENTRY_TESTS.getName())
 167                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(entryTestFilePath).append("\n")
 168                 .append(ETSI_ENTRY_LICENSES.getName())
 169                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(entryLicenseFilePath).append("\n");
 170
 171         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 172         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 173         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 174
 175         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 176         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 177         handler.addFile(entryTestFilePath, "".getBytes());
 178         handler.addFile(entryLicenseFilePath, "".getBytes());
 179
 180         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 181                 .withSource(TOSCA_META_PATH_FILE_NAME)
 182                 .withSource(TOSCA_DEFINITION_FILEPATH)
 183                 .withSource(TOSCA_CHANGELOG_FILEPATH)
 184                 .withSource(TOSCA_MANIFEST_FILEPATH).withSource(SAMPLE_SOURCE)
 185                 .withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH)
 186                 .withSource(entryTestFilePath)
 187                 .withSource(entryLicenseFilePath);
 188
 189         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 190
 191         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 192
 193         assertEquals(0, errors.size());
 194     }
 195
 196     @Test
 197     public void testGivenTOSCAMeta_withUnsupportedEntry_thenNoErrorIsReturned() {
 198         metaFileBuilder
 199                 .append("a-unknown-entry")
 200                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ")
 201                 .append("Definitions/events.log");
 202
 203         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 204         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 205         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 206         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 207                 .withSource(TOSCA_META_PATH_FILE_NAME)
 208                 .withSource(TOSCA_DEFINITION_FILEPATH)
 209                 .withSource(TOSCA_CHANGELOG_FILEPATH)
 210                 .withSource(TOSCA_MANIFEST_FILEPATH);
 211
 212         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 213         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 214         assertThat("Validation should produce no errors", errors, is(anEmptyMap()));
 215     }
 216
 217     /**
 218      * Tests if the meta file contains invalid versions in TOSCA-Meta-File-Version and CSAR-Version attributes.
 219      */
 220     @Test
 221     public void testGivenTOSCAMetaFile_withInvalidTOSCAMetaFileVersionAndCSARVersion_thenErrorIsReturned() {
 222         final StringBuilder metaFileBuilder = new StringBuilder()
 223                 .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 224                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(Integer.MAX_VALUE).append("\n")
 225                 .append(CSAR_VERSION_ENTRY.getName())
 226                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(Integer.MAX_VALUE).append("\n")
 227                 .append(CREATED_BY_ENTRY.getName())
 228                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 229                 .append(ENTRY_DEFINITIONS.getName())
 230                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 231                 .append(ETSI_ENTRY_MANIFEST.getName())
 232                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_MANIFEST_FILEPATH).append("\n")
 233                 .append(ETSI_ENTRY_CHANGE_LOG.getName())
 234                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH);
 235         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 236
 237         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 238         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 239
 240         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 241         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 242
 243         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 244         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 245
 246         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 247         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 248
 249         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 250         assertExpectedErrors("Invalid TOSCA-Meta-File-Version and CSAR-Version attributes", errors, 2);
 251     }
 252
 253     @Test
 254     public void testGivenTOSCAMetaFile_withNonExistentFileReferenced_thenErrorsReturned() {
 255         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 256
 257         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 258         assertThat("Total of errors should be as expected", errors.size(), is(1));
 259         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 260         assertThat("Total of errors messages should be as expected", errorMessages.size(), is((2 + getManifestDefinitionErrorCount())));
 261     }
 262
 263
 264     @Test
 265     public void testGivenDefinitionFile_whenValidImportStatementExist_thenNoErrorsReturned() {
 266         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 267
 268         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 269         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 270
 271         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 272         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 273
 274         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 275         manifestBuilder.withSource(SAMPLE_SOURCE);
 276
 277         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml",
 278                 getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 279         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 280
 281         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithValidImports.yaml";
 282         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 283         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 284
 285         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 286         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 287
 288         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 289         assertEquals(0, errors.size());
 290     }
 291
 292     @Test
 293     public void testGivenDefinitionFile_whenMultipleDefinitionsImportStatementExist_thenNoErrorsReturned() {
 294         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 295
 296         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 297         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 298
 299         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 300         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 301
 302         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 303         manifestBuilder.withSource(SAMPLE_SOURCE);
 304
 305         final byte[] sampleDefinitionFile1 =
 306                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile1.yaml");
 307         handler.addFile(TOSCA_DEFINITION_FILEPATH, sampleDefinitionFile1);
 308         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 309
 310         final byte[] sampleDefinitionFile2 =
 311                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 312         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", sampleDefinitionFile2);
 313         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 314
 315         final byte[] sampleDefinitionFile3 =
 316                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile1.yaml");
 317         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile3);
 318         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 319
 320         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 321         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 322
 323         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 324         assertEquals(0, errors.size());
 325     }
 326
 327     @Test
 328     public void testGivenDefinitionFile_whenInvalidImportStatementExist_thenErrorIsReturned() {
 329         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 330
 331         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 332         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 333
 334         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 335         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 336
 337         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 338         manifestBuilder.withSource(SAMPLE_SOURCE);
 339
 340         final String definitionFileWithInvalidImports =
 341                 "validation.files/definition/definitionFileWithInvalidImport.yaml";
 342         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithInvalidImports));
 343         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 344
 345         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 346         String manifest = manifestBuilder.build();
 347         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifest.getBytes(StandardCharsets.UTF_8));
 348
 349         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 350         assertExpectedErrors("", errors, getManifestDefinitionErrorCount());
 351     }
 352
 353     /**
 354      * Manifest referenced import file missing
 355      */
 356     @Test
 357     public void testGivenDefinitionFile_whenReferencedImportDoesNotExist_thenErrorIsReturned() {
 358         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 359
 360         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 361         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 362
 363         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 364         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 365
 366         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 367         manifestBuilder.withSource(SAMPLE_SOURCE);
 368
 369         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", "".getBytes());
 370         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 371
 372         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 373         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 374                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 375
 376         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 377         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 378
 379         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 380         assertExpectedErrors("Manifest referenced import file missing", errors, getManifestDefinitionErrorCount());
 381     }
 382
 383     @Test
 384     public void testGivenDefinitionFile_whenFileInPackageNotInManifest_thenErrorIsReturned() {
 385         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 386
 387         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 388         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 389
 390         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 391         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 392
 393         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 394
 395         final byte[] sampleDefinitionFile =
 396                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 397         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile);
 398         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 399
 400         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 401         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 402                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 403
 404         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 405
 406         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 407         assertExpectedErrors("Artifact is not being referenced in manifest file", errors, 1);
 408     }
 409
 410     @Test
 411     public void testGivenDefinitionFile_whenManifestNotreferencedInManifest_thenNoErrorIsReturned() {
 412         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 413
 414         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 415         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 416
 417         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 418         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 419
 420         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 421         manifestBuilder.withSource(SAMPLE_SOURCE);
 422
 423         final byte[] sampleDefinitionFile =
 424                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 425         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile);
 426         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 427
 428         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 429         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 430                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 431
 432         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 433
 434         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 435         assertEquals(0, errors.size());
 436     }
 437
 438     /**
 439      * Reference with invalid YAML format.
 440      */
 441     @Test
 442     public void testGivenDefinitionFile_withInvalidYAML_thenErrorIsReturned() {
 443         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 444
 445         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 446         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 447
 448         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 449         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 450
 451         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 452         manifestBuilder.withSource(SAMPLE_SOURCE);
 453
 454         final String definitionFileWithInvalidYAML = "validation.files/definition/invalidDefinitionFile.yaml";
 455         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithInvalidYAML));
 456         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 457
 458         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 459         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 460
 461         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 462         assertExpectedErrors("Reference with invalid YAML format", errors, getManifestDefinitionErrorCount());
 463     }
 464
 465     @Test
 466     public void testGivenManifestFile_withValidSourceAndNonManoSources_thenNoErrorIsReturned() throws IOException {
 467         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 468
 469         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 470         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 471
 472         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 473         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 474
 475         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 476         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 477
 478         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 479         manifestBuilder.withSource(SAMPLE_SOURCE);
 480
 481         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 482         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 483
 484         final String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 485         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 486         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 487
 488         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 489         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 490
 491         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 492         assertEquals(0, errors.size());
 493     }
 494
 495     /**
 496      * Manifest with non existent source files should return error.
 497      */
 498     @Test
 499     public void testGivenManifestFile_withNonExistentSourceFile_thenErrorIsReturned() throws IOException {
 500         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 501         //non existent reference
 502         manifestBuilder.withSource("Artifacts/Deployment/Events/RadioNode_pnf_v1.yaml");
 503
 504         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 505         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 506
 507         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 508         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 509
 510         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 511         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 512
 513         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 514         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 515
 516         String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 517         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 518         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 519
 520         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 521         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 522
 523         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 524         assertExpectedErrors("Manifest with non existent source files", errors, 1);
 525     }
 526
 527     /**
 528      * Tests the validation for a TOSCA Manifest with invalid data.
 529      */
 530     @Test
 531     public void testGivenManifestFile_withInvalidData_thenErrorIsReturned() {
 532         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 533         handler.addFile(TOSCA_MANIFEST_FILEPATH, getResourceBytesOrFail("validation.files/manifest/invalidManifest.mf"));
 534         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 535         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 536         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 537
 538         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 539         assertExpectedErrors("TOSCA manifest with invalid data", errors, 1);
 540     }
 541
 542     @Test
 543     public void testGivenManifestAndDefinitionFile_withSameNames_thenNoErrorReturned()  {
 544         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 545
 546         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 547         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 548
 549         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 550         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 551
 552         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 553         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 554
 555         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 556         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 557
 558         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 559         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 560
 561         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 562         assertEquals(0, errors.size());
 563     }
 564
 565     /**
 566      * Main TOSCA definitions file and Manifest file with different name should return error.
 567      */
 568     @Test
 569     public void testGivenManifestAndMainDefinitionFile_withDifferentNames_thenErrorIsReturned() {
 570         metaFileBuilder = new StringBuilder()
 571                 .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 572                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 573                 .append(CSAR_VERSION_ENTRY.getName())
 574                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 575                 .append(CREATED_BY_ENTRY.getName())
 576                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 577                 .append(ENTRY_DEFINITIONS.getName())
 578                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 579                 .append(ETSI_ENTRY_MANIFEST.getName())
 580                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate2.mf\n")
 581                 .append(ETSI_ENTRY_CHANGE_LOG.getName())
 582                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 583
 584         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 585
 586         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 587         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 588
 589         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 590         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 591
 592         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 593         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 594
 595         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 596         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 597
 598         manifestBuilder.withSource("Definitions/MainServiceTemplate2.mf");
 599         handler.addFile("Definitions/MainServiceTemplate2.mf", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 600
 601         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 602         assertExpectedErrors("Main TOSCA definitions file and Manifest file with different name should return error",
 603                 errors, 1);
 604     }
 605
 606     @Test
 607     public void testGivenManifestFile_withDifferentExtension_thenErrorIsReturned() {
 608         metaFileBuilder = new StringBuilder()
 609                 .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 610                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 611                 .append(CSAR_VERSION_ENTRY.getName())
 612                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 613                 .append(CREATED_BY_ENTRY.getName())
 614                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 615                 .append(ENTRY_DEFINITIONS.getName())
 616                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 617                 .append(ETSI_ENTRY_MANIFEST.getName())
 618                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate.txt\n")
 619                 .append(ETSI_ENTRY_CHANGE_LOG.getName())
 620                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 621
 622         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 623
 624         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 625         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 626
 627         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 628         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 629
 630         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 631         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 632
 633         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 634         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 635
 636         manifestBuilder.withSource("Definitions/MainServiceTemplate.txt");
 637         handler.addFile("Definitions/MainServiceTemplate.txt", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 638
 639         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 640         assertExpectedErrors("Manifest file with different extension than .mf should return error",
 641                 errors, 1);
 642     }
 643
 644     @Test
 645     public void testGivenManifestFile_withValidVnfMetadata_thenNoErrorsReturned() {
 646         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 647
 648         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 649         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 650         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 651         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 652         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 653         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 654
 655         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 656         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 657
 658         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 659         assertExpectedErrors("Manifest with valid vnf mandatory values should not return any errors", errors, 0);
 660     }
 661
 662     @Test
 663     public void testGivenManifestFile_withValidPnfMetadata_thenNoErrorsReturned() {
 664         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 665
 666         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 667         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 668
 669         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 670         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 671
 672         manifestBuilder.withSignedSource(TOSCA_DEFINITION_FILEPATH
 673                 , "SHA-abc", "09e5a788acb180162c51679ae4c998039fa6644505db2415e35107d1ee213943");
 674         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 675
 676         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 677         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 678
 679         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 680         assertExpectedErrors("Manifest with valid pnf mandatory values should not return any errors", errors, 0);
 681     }
 682
 683     /**
 684      * Manifest with mixed metadata should return error.
 685      */
 686     @Test
 687     public void testGivenManifestFile_withMetadataContainingMixedPnfVnfMetadata_thenErrorIsReturned() {
 688         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 689                 .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 690                 .withMetaData(VNF_PROVIDER_ID.getToken(), "Bilal Iqbal")
 691                 .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 692                 .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 693
 694         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 695         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 696         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 697         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 698         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 699         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 700
 701         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 702         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 703
 704         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 705         assertExpectedErrors("Manifest with mixed metadata should return error", errors, 1);
 706     }
 707
 708
 709     @Test
 710     public void testGivenManifestFile_withMetadataMissingPnfOrVnfMandatoryEntries_thenErrorIsReturned() {
 711         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 712                 .withMetaData("invalid_product_name", "RadioNode")
 713                 .withMetaData("invalid_provider_id", "Bilal Iqbal")
 714                 .withMetaData("invalid_package_version", "1.0")
 715                 .withMetaData("invalid_release_date_time", "2019-12-14T11:25:00+00:00");
 716
 717         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 718         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 719
 720         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 721         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 722
 723         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 724         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 725
 726         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 727         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 728
 729         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 730         assertExpectedErrors("Manifest with missing vnf or pnf mandatory entries should return error", errors, 1);
 731     }
 732
 733     @Test
 734     public void testGivenManifestFile_withMetadataMissingMandatoryPnfEntries_thenErrorIsReturned() {
 735         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 736
 737         manifestBuilder.withMetaData(PNFD_NAME.getToken(), "RadioNode");
 738         manifestBuilder.withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 739
 740         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 741         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 742
 743         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 744         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 745
 746         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 747         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 748
 749         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 750         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 751
 752         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 753         assertExpectedErrors("Manifest with metadata missing pnf mandatory entries should return error", errors, 1);
 754
 755     }
 756
 757     @Test
 758     public void testGivenManifestFile_withMetadataMissingMandatoryVnfEntries_thenErrorIsReturned() {
 759         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 760
 761         manifestBuilder.withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode");
 762
 763         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 764         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 765
 766         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 767         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 768
 769         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 770         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 771
 772         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 773         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 774
 775         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 776         assertExpectedErrors("Manifest with metadata missing vnf mandatory entries should return error", errors, 1);
 777
 778     }
 779
 780     /**
 781      * Manifest with more than 4 metadata entries should return error.
 782      */
 783     @Test
 784     public void testGivenManifestFile_withMetadataEntriesExceedingTheLimit_thenErrorIsReturned() {
 785         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 786                 .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 787                 .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "Bilal Iqbal")
 788                 .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 789                 .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 790
 791         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 792         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 793
 794         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 795         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 796
 797         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 798         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 799
 800         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 801         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 802
 803         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 804         assertExpectedErrors("Manifest with more than 4 metadata entries should return error", errors, 1);
 805     }
 806
 807     @Test
 808     public void testGivenManifestFile_withPnfMetadataAndVfEntries_thenErrorIsReturned() {
 809         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 810         metaFileBuilder
 811                 .append(ETSI_ENTRY_TESTS.getName())
 812                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Tests").append("\n")
 813                 .append(ETSI_ENTRY_LICENSES.getName())
 814                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Licenses");
 815
 816         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 817         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 818
 819         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 820         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 821
 822         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 823         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 824
 825         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 826         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 827         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 828         assertExpectedErrors("Tosca.meta should not have entries applicable only to VF", errors, 2);
 829
 830     }
 831
 832     /**
 833      * Tests an imported descriptor with a missing imported file.
 834      */
 835     @Test
 836     public void testGivenDefinitionFileWithImportedDescriptor_whenImportedDescriptorImportsMissingFile_thenMissingImportErrorOccur() {
 837         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 838
 839         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 840         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 841
 842         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 843         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 844
 845         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 846         manifestBuilder.withSource(SAMPLE_SOURCE);
 847
 848         final String definitionImportOne = "Definitions/importOne.yaml";
 849         handler.addFile(definitionImportOne,
 850                 getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 851         manifestBuilder.withSource(definitionImportOne);
 852
 853         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 854         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 855         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 856
 857         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 858         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 859
 860         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 861
 862         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 863         for (int i =0;i < getManifestDefinitionErrorCount();i++)
 864             expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 865                     , Messages.MISSING_IMPORT_FILE.formatMessage("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml"))
 866                     );
 867
 868         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 869     }
 870
 871     /**
 872      * Tests an imported descriptor with invalid import statement.
 873      */
 874     @Test
 875     public void testGivenDefinitionFileWithImportedDescriptor_whenInvalidImportStatementExistInImportedDescriptor_thenInvalidImportErrorOccur() {
 876         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 877
 878         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 879         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 880
 881         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 882         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 883
 884         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 885         manifestBuilder.withSource(SAMPLE_SOURCE);
 886
 887         final String definitionImportOne = "Definitions/importOne.yaml";
 888         handler.addFile(definitionImportOne,
 889                 getResourceBytesOrFail("validation.files/definition/definitionFileWithInvalidImport.yaml"));
 890         manifestBuilder.withSource(definitionImportOne);
 891
 892         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 893         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 894         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 895
 896         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 897         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 898
 899         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 900
 901         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 902         for (int i =0;i < getManifestDefinitionErrorCount();i++)
 903             expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 904                 , Messages.INVALID_IMPORT_STATEMENT.formatMessage(definitionImportOne, "null"))
 905          );
 906
 907         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 908     }
 909
 910     @Test
 911     public void givenManifestWithNonManoPmAndVesArtifacts_whenNonManoArtifactsAreValid_thenNoErrorsOccur() {
 912         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 913
 914         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 915         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 916
 917         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 918         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 919
 920         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 921         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 922
 923         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 924         handler.addFile(nonManoPmEventsSource,
 925                 getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 926         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 927
 928         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 929         handler.addFile(nonManoVesEventsSource,
 930                 getResourceBytesOrFail("validation.files/events/vesEvents-valid.yaml"));
 931         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 932
 933         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 934         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 935
 936         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 937                 .validateContent(handler);
 938
 939         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
 940     }
 941
 942     @Test
 943     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreInvalid_thenInvalidYamlErrorOccur() {
 944         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 945
 946         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 947         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 948
 949         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 950         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 951
 952         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 953         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 954
 955         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 956         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(INVALID_YAML_FILE_PATH));
 957         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 958
 959         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 960         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 961
 962         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 963         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 964                 , Messages.INVALID_YAML_FORMAT_1.formatMessage(nonManoPmEventsSource, "while scanning a simple key in 'reader', line 2, column 1: key {} ^could not find expected ':' in 'reader', line 2, column 7: key {} ^"))
 965         );
 966         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR, "while scanning a simple key in 'reader', line 2, column 1: key {} ^could not find expected ':' in 'reader', line 2, column 7: key {} ^")
 967             );
 968
 969         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 970         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 971     }
 972
 973     @Test
 974     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreEmpty_thenEmptyYamlErrorOccur() {
 975         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 976
 977         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 978         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 979
 980         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 981         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 982
 983         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 984         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 985
 986         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 987         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 988         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 989
 990         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 991         handler.addFile(nonManoVesEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 992         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 993
 994         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 995         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 996
 997         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 998         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 999                 , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoPmEventsSource))
1000         );
1001         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1002                 , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoVesEventsSource))
1003         );
1004         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1005                 , "PM_Dictionary YAML file is empty")
1006         );
1007
1008         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
1009             .validateContent(handler);
1010
1011         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1012     }
1013
1014     @Test
1015     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsHaveNotYamlExtension_thenInvalidYamlExtensionErrorOccur() {
1016         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
1017
1018         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
1019         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1020
1021         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1022         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1023
1024         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1025         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1026
1027         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.y1";
1028         handler.addFile(nonManoPmEventsSource, "".getBytes());
1029         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
1030
1031         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.y2";
1032         handler.addFile(nonManoVesEventsSource, "".getBytes());
1033         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
1034
1035         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1036         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1037
1038         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1039         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1040                 , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoPmEventsSource))
1041         );
1042         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1043                 , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoVesEventsSource))
1044         );
1045         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1046                 , "PM_Dictionary YAML file is empty")
1047         );
1048
1049
1050         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
1051                 .validateContent(handler);
1052
1053         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1054     }
1055
1056     @Test
1057     public void givenPackageWithValidSoftwareInformationNonMano_whenThePackageIsValidated_thenNoErrorsAreReturned() {
1058         //given a package with software information non-mano artifact
1059         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1060         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
1061         handler.addFile(nonManoSoftwareInformationPath,
1062                 getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1063         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1064         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1065                 .getBytes(StandardCharsets.UTF_8));
1066         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1067         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1068         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1069         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1070         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1071
1072         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1073         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1074         //when package is validated
1075         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1076         //then no errors
1077         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
1078     }
1079
1080     @Test
1081     public void givenPackageWithUnparsableSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
1082         //given a package with unparsable software information non-mano artifact
1083         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1084         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
1085         handler.addFile(nonManoSoftwareInformationPath,
1086                 getResourceBytesOrFail("validation.files/invalid.yaml"));
1087         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1088         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1089                 .getBytes(StandardCharsets.UTF_8));
1090         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1091         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1092         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1093         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1094         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1095
1096         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1097         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1098         //when package is validated
1099         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1100         //then invalid error returned
1101         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1102         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1103                 , Messages.INVALID_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1104         );
1105         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1106     }
1107
1108     @Test
1109     public void givenPackageWithIncorrectSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
1110         //given a package with incorrect software information non-mano artifact
1111         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1112         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-invalid.yaml";
1113         handler.addFile(nonManoSoftwareInformationPath,
1114                 getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-invalid.yaml"));
1115         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1116         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1117                 .getBytes(StandardCharsets.UTF_8));
1118         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1119         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1120         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1121         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1122         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1123
1124         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1125         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1126         //when package is validated
1127         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1128         //then incorrect error returned
1129         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1130         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1131                 , Messages.INCORRECT_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1132         );
1133         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1134     }
1135
1136     @Test
1137     public void givenPackageWithTwoSoftwareInformationNonMano_whenThePackageIsValidated_thenUniqueErrorIsReturned() {
1138         //given a package with two software information non-mano artifacts
1139         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1140         final String nonManoSoftwareInformation1Path = "Artifacts/software-information/pnf-sw-information-valid1.yaml";
1141         handler.addFile(nonManoSoftwareInformation1Path,
1142                 getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1143         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation1Path);
1144         final String nonManoSoftwareInformation2Path = "Artifacts/software-information/pnf-sw-information-valid2.yaml";
1145         handler.addFile(nonManoSoftwareInformation2Path,
1146                 getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1147         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation2Path);
1148         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1149                 .getBytes(StandardCharsets.UTF_8));
1150         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1151         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1152         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1153         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1154         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1155
1156         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1157         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1158         //when package is validated
1159         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1160         //then unique error returned
1161         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1162         final String errorFiles = Stream.of(nonManoSoftwareInformation1Path, nonManoSoftwareInformation2Path)
1163                 .map(s -> String.format("'%s'", s))
1164                 .collect(Collectors.joining(", "));
1165         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1166                 , Messages.UNIQUE_SW_INFORMATION_NON_MANO_ERROR.formatMessage(errorFiles))
1167         );
1168         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1169     }
1170
1171     @Test
1172     public void signedPackage() throws SecurityManagerException {
1173         //given
1174         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1175         final String fakeArtifactPath = "Artifacts/aArtifact.yaml";
1176         final String fakeArtifactCmsPath = "Artifacts/aArtifact.cms";
1177         final String fakeCertificatePath = "certificate.cert";
1178         handler.addFile(fakeArtifactPath, new byte[0]);
1179         manifestBuilder.withSource(fakeArtifactPath);
1180         handler.addFile(fakeArtifactCmsPath, new byte[0]);
1181         manifestBuilder.withSource(fakeArtifactCmsPath);
1182         handler.addFile(fakeCertificatePath, new byte[0]);
1183         manifestBuilder.withSource(fakeCertificatePath);
1184         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1185         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1186         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1187         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1188
1189         metaFileBuilder.append(ETSI_ENTRY_CERTIFICATE.getName())
1190                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(fakeCertificatePath).append("\n");
1191         handler.addFile(TOSCA_META_PATH_FILE_NAME,
1192                 metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
1193         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1194
1195         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1196         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1197
1198         final SecurityManager securityManagerMock = mock(SecurityManager.class);
1199         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(true);
1200         sol004MetaDirectoryValidator = getSol004WithSecurity(securityManagerMock);
1201
1202         //when
1203         Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1204         //then
1205         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
1206
1207         //given
1208         sol004MetaDirectoryValidator = getSol004WithSecurity(securityManagerMock);
1209         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(false);
1210
1211         //when
1212         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1213
1214         //then
1215         List<ErrorMessage> expectedErrorList = new ArrayList<>();
1216         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1217                 , Messages.ARTIFACT_INVALID_SIGNATURE.formatMessage(fakeArtifactCmsPath, fakeArtifactPath))
1218         );
1219         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1220
1221         //given
1222         sol004MetaDirectoryValidator = getSol004WithSecurity(securityManagerMock);
1223         when(securityManagerMock.verifySignedData(any(), any(), any()))
1224                 .thenThrow(new SecurityManagerException("SecurityManagerException"));
1225         //when
1226         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1227
1228         //then
1229         expectedErrorList = new ArrayList<>();
1230         expectedErrorList.add(
1231             new ErrorMessage(ErrorLevel.ERROR,
1232                 Messages.ARTIFACT_SIGNATURE_VALIDATION_ERROR.formatMessage(fakeArtifactCmsPath,
1233                     fakeArtifactPath, fakeCertificatePath, "SecurityManagerException")
1234             )
1235         );
1236         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1237     }
1238
1239     protected void assertExpectedErrors(final String testCase, final Map<String, List<ErrorMessage>> errors, final int expectedErrors){
1240         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
1241         printErrorMessages(errorMessages);
1242         if (expectedErrors > 0) {
1243             assertEquals(testCase, expectedErrors, errorMessages.size());
1244         } else {
1245             assertEquals(testCase, expectedErrors, errors.size());
1246         }
1247     }
1248
1249     private void printErrorMessages(final List<ErrorMessage> errorMessages) {
1250         if (CollectionUtils.isNotEmpty(errorMessages)) {
1251             errorMessages.forEach(errorMessage ->
1252                     System.out.println(String.format("%s: %s", errorMessage.getLevel(), errorMessage.getMessage()))
1253             );
1254         }
1255     }
1256
1257     private void assertExpectedErrors(List<ErrorMessage> actualErrorList, final List<ErrorMessage> expectedErrorList) {
1258         if (actualErrorList == null) {
1259             actualErrorList = new ArrayList<>();
1260         }
1261
1262         printErrorMessages(actualErrorList);
1263
1264         assertThat("The actual error list should have the same size as the expected error list"
1265                 , actualErrorList, hasSize(expectedErrorList.size())
1266         );
1267
1268         actualErrorList.forEach(error -> {
1269             Predicate<ErrorMessage> matching = e -> e.getLevel() == error.getLevel() && sanitize(e.getMessage()).equalsIgnoreCase(sanitize(error.getMessage()));
1270             assertTrue("The actual error and expected error lists should be the same", expectedErrorList.stream().anyMatch(matching));
1271         });
1272     }
1273
1274     private static String sanitize(String s) {
1275         return s.trim().replaceAll("\n", "").replaceAll("\r", "").replaceAll("\\s{2,}", " ").trim();
1276     }
1277
1278 }