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