gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation;
  22
  23 import static org.hamcrest.MatcherAssert.assertThat;
  24 import static org.hamcrest.Matchers.containsInAnyOrder;
  25 import static org.hamcrest.Matchers.hasSize;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertSame;
  28 import static org.junit.Assert.assertTrue;
  29 import static org.junit.Assert.fail;
  30 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ENTRY_DEFINITIONS;
  31 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_CERTIFICATE;
  32 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_CHANGE_LOG;
  33 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_LICENSES;
  34 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_MANIFEST;
  35 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_TESTS;
  36 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_PATH_FILE_NAME;
  37 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.ATTRIBUTE_VALUE_SEPARATOR;
  38 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_ARCHIVE_VERSION;
  39 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_NAME;
  40 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_RELEASE_DATE_TIME;
  41 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PACKAGE_VERSION;
  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.vendorsoftwareproduct.impl.orchestration.csar.validation.NonManoArtifactType.ONAP_PM_DICTIONARY;
  46 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.NonManoArtifactType.ONAP_VES_EVENTS;
  47 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.EMPTY_YAML_FILE_PATH;
  48 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.INVALID_YAML_FILE_PATH;
  49 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_FILE_PATH;
  50 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_IMPORT_FILE_PATH;
  51 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_SOURCE;
  52 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_CHANGELOG_FILEPATH;
  53 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_DEFINITION_FILEPATH;
  54 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_MANIFEST_FILEPATH;
  55
  56 import java.io.IOException;
  57 import java.nio.charset.StandardCharsets;
  58 import java.util.ArrayList;
  59 import java.util.Collections;
  60 import java.util.List;
  61 import java.util.Map;
  62 import org.apache.commons.collections.CollectionUtils;
  63 import org.junit.Before;
  64 import org.junit.Test;
  65 import org.openecomp.core.utilities.file.FileContentHandler;
  66 import org.openecomp.sdc.common.errors.Messages;
  67 import org.openecomp.sdc.common.utils.SdcCommon;
  68 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  69 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  70 import org.openecomp.sdc.logging.api.Logger;
  71 import org.openecomp.sdc.logging.api.LoggerFactory;
  72 import org.openecomp.sdc.tosca.csar.ManifestTokenType;
  73
  74 public class SOL004MetaDirectoryValidatorTest {
  75
  76     private static final Logger LOGGER = LoggerFactory.getLogger(SOL004MetaDirectoryValidatorTest.class);
  77
  78     private SOL004MetaDirectoryValidator sol004MetaDirectoryValidator;
  79     private FileContentHandler handler;
  80     private String metaFile;
  81
  82     @Before
  83     public void setUp() {
  84         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator();
  85         handler = new FileContentHandler();
  86         metaFile =
  87                 "TOSCA-Meta-File-Version: 1.0\n"+
  88                 "CSAR-Version: 1.1\n"+
  89                 "Created-By: Vendor\n"+
  90                 TOSCA_META_ENTRY_DEFINITIONS + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Definitions/MainServiceTemplate.yaml\n"+
  91                 TOSCA_META_ETSI_ENTRY_MANIFEST + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Definitions/MainServiceTemplate.mf\n"+
  92                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Artifacts/changeLog.text\n";
  93     }
  94
  95     @Test
  96     public void testGivenTOSCAMetaFile_whenEntryHasNoValue_thenErrorIsReturned() {
  97         final String metaFileWithInvalidEntry = "TOSCA-Meta-File-Version: \n" +
  98                 "Entry-Definitions: Definitions/MainServiceTemplate.yaml";
  99
 100         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileWithInvalidEntry.getBytes(StandardCharsets.UTF_8));
 101         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 102
 103         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 104         assertExpectedErrors("TOSCA Meta file with no entries", errors, 1);
 105     }
 106
 107     @Test
 108     public void testGivenTOSCAMeta_withAllSupportedEntries_thenNoErrorsReturned() {
 109
 110         final String entryTestFilePath = "Files/Tests";
 111         final String entryLicenseFilePath = "Files/Licenses";
 112
 113         handler.addFolder("Files/Tests/");
 114         handler.addFolder("Files/Licenses/");
 115
 116         metaFile = metaFile +
 117                 TOSCA_META_ETSI_ENTRY_TESTS + ATTRIBUTE_VALUE_SEPARATOR.getToken() + entryTestFilePath + "\n" +
 118                 TOSCA_META_ETSI_ENTRY_LICENSES + ATTRIBUTE_VALUE_SEPARATOR.getToken() + entryLicenseFilePath +"\n";
 119
 120         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 121         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 122         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 123
 124         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 125         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 126         handler.addFile(entryTestFilePath, "".getBytes());
 127         handler.addFile(entryLicenseFilePath, "".getBytes());
 128
 129         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 130             .withSource(TOSCA_META_PATH_FILE_NAME)
 131             .withSource(TOSCA_DEFINITION_FILEPATH)
 132             .withSource(TOSCA_CHANGELOG_FILEPATH)
 133             .withSource(TOSCA_MANIFEST_FILEPATH).withSource(SAMPLE_SOURCE)
 134             .withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH)
 135             .withSource(entryTestFilePath)
 136             .withSource(entryLicenseFilePath);
 137
 138         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 139
 140         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 141         assertEquals(0, errors.size());
 142     }
 143
 144     @Test
 145     public void testGivenTOSCAMeta_withUnsupportedEntry_thenWarningIsReturned() {
 146         metaFile = "Entry-Events: Definitions/events.log";
 147
 148         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 149         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 150         List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 151         assertTrue(errors.size() == 1 && errorMessages.size() == 1);
 152         assertSame(ErrorLevel.ERROR, errorMessages.get(0).getLevel());
 153     }
 154
 155     /**
 156      * Tests if the meta file contains invalid versions in TOSCA-Meta-File-Version and CSAR-Version attributes.
 157      */
 158     @Test
 159     public void testGivenTOSCAMetaFile_withInvalidTOSCAMetaFileVersionAndCSARVersion_thenErrorIsReturned() {
 160         final String metaFile =
 161                 "TOSCA-Meta-File-Version: " + Integer.MAX_VALUE +
 162                 "\nCSAR-Version: " + Integer.MAX_VALUE  +
 163                 "\nCreated-By: Bilal Iqbal\n" +
 164                 TOSCA_META_ENTRY_DEFINITIONS + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Definitions/MainServiceTemplate.yaml\n" +
 165                 TOSCA_META_ETSI_ENTRY_MANIFEST + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Definitions/MainServiceTemplate.mf\n"+
 166                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Artifacts/changeLog.text";
 167
 168         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 169
 170         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 171         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 172
 173         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 174         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 175
 176         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 177         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 178
 179         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 180         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 181
 182         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 183         assertExpectedErrors("Invalid TOSCA-Meta-File-Version and CSAR-Version attributes", errors, 2);
 184     }
 185
 186     @Test
 187     public void testGivenTOSCAMetaFile_withNonExistentFileReferenced_thenErrorsReturned() {
 188         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 189
 190         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 191         List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 192         assertTrue(errors.size() == 1 && errorMessages.size() == 3);
 193     }
 194
 195
 196     @Test
 197     public void testGivenDefinitionFile_whenValidImportStatementExist_thenNoErrorsReturned() {
 198         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 199
 200         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 201         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 202
 203         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 204         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 205
 206         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 207         manifestBuilder.withSource(SAMPLE_SOURCE);
 208
 209         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 210         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 211
 212         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithValidImports.yaml";
 213         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 214         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 215
 216         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 217         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 218
 219         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 220         assertEquals(0, errors.size());
 221     }
 222
 223     @Test
 224     public void testGivenDefinitionFile_whenMultipleDefinitionsImportStatementExist_thenNoErrorsReturned() {
 225         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 226
 227         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 228         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 229
 230         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 231         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 232
 233         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 234         manifestBuilder.withSource(SAMPLE_SOURCE);
 235
 236         final byte [] sampleDefinitionFile1 = getResourceBytes("/validation.files/definition/sampleDefinitionFile1.yaml");
 237         handler.addFile(TOSCA_DEFINITION_FILEPATH, sampleDefinitionFile1);
 238         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 239
 240         final byte [] sampleDefinitionFile2 = getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml");
 241         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", sampleDefinitionFile2);
 242         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 243
 244         final byte [] sampleDefinitionFile3 = getResourceBytes("/validation.files/definition/sampleDefinitionFile1.yaml");
 245         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile3);
 246         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 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         assertEquals(0, errors.size());
 253     }
 254
 255     @Test
 256     public void testGivenDefinitionFile_whenInvalidImportStatementExist_thenErrorIsReturned() {
 257         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 258
 259         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 260         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 261
 262         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 263         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 264
 265         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 266         manifestBuilder.withSource(SAMPLE_SOURCE);
 267
 268         final String definitionFileWithInvalidImports = "/validation.files/definition/definitionFileWithInvalidImport.yaml";
 269         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithInvalidImports));
 270         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 271
 272         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 273         String manifest = manifestBuilder.build();
 274         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifest.getBytes(StandardCharsets.UTF_8));
 275
 276         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 277         assertExpectedErrors("", errors, 1);
 278     }
 279
 280     /**
 281      * Manifest referenced import file missing
 282      */
 283     @Test
 284     public void testGivenDefinitionFile_whenReferencedImportDoesNotExist_thenErrorIsReturned() {
 285         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 286
 287         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 288         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 289
 290         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 291         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 292
 293         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 294         manifestBuilder.withSource(SAMPLE_SOURCE);
 295
 296         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", "".getBytes());
 297         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 298
 299         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 300         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml"));
 301
 302         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 303         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 304
 305         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 306         assertExpectedErrors("Manifest referenced import file missing", errors, 1);
 307     }
 308
 309     /**
 310      * Reference with invalid YAML format.
 311      */
 312     @Test
 313     public void testGivenDefinitionFile_withInvalidYAML_thenErrorIsReturned() {
 314         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 315
 316         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 317         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 318
 319         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 320         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 321
 322         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 323         manifestBuilder.withSource(SAMPLE_SOURCE);
 324
 325         final String definitionFileWithInvalidYAML = "/validation.files/definition/invalidDefinitionFile.yaml";
 326         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithInvalidYAML));
 327         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 328
 329         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 330         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 331
 332         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 333         assertExpectedErrors("Reference with invalid YAML format", errors, 1);
 334     }
 335
 336     @Test
 337     public void testGivenManifestFile_withValidSourceAndNonManoSources_thenNoErrorIsReturned() {
 338         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 339
 340         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 341         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 342
 343         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 344         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 345
 346         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 347         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 348
 349         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 350         manifestBuilder.withSource(SAMPLE_SOURCE);
 351
 352         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 353         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 354
 355         final String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 356         handler.addFile(nonManoSource, getResourceBytes("/validation.files/measurements/pmEvents-valid.yaml"));
 357         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 358
 359         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 360         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 361
 362         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 363         assertEquals(0, errors.size());
 364     }
 365
 366     /**
 367      * Manifest with non existent source files should return error.
 368      */
 369     @Test
 370     public void testGivenManifestFile_withNonExistentSourceFile_thenErrorIsReturned() {
 371         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 372         //non existent reference
 373         manifestBuilder.withSource("Artifacts/Deployment/Events/RadioNode_pnf_v1.yaml");
 374
 375         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 376         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 377
 378         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 379         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 380
 381         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 382         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 383
 384         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 385         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 386
 387         String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 388         handler.addFile(nonManoSource, getResourceBytes("/validation.files/measurements/pmEvents-valid.yaml"));
 389         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 390
 391         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 392         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 393
 394         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 395         assertExpectedErrors("Manifest with non existent source files", errors, 1);
 396     }
 397
 398     /**
 399      * Tests the validation for a TOSCA Manifest with invalid data.
 400      */
 401     @Test
 402     public void testGivenManifestFile_withInvalidData_thenErrorIsReturned() {
 403         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 404         handler.addFile(TOSCA_MANIFEST_FILEPATH, getResourceBytes("/validation.files/manifest/invalidManifest.mf"));
 405         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 406         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 407         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 408
 409         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 410         assertExpectedErrors("TOSCA manifest with invalid data", errors, 1);
 411     }
 412
 413     @Test
 414     public void testGivenManifestAndDefinitionFile_withSameNames_thenNoErrorReturned()  {
 415         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 416
 417         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 418         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 419
 420         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 421         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 422
 423         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 424         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 425
 426         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 427         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 428
 429         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 430         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 431
 432         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 433         assertEquals(0, errors.size());
 434     }
 435
 436     /**
 437      * Main TOSCA definitions file and Manifest file with different name should return error.
 438      */
 439     @Test
 440     public void testGivenManifestAndMainDefinitionFile_withDifferentNames_thenErrorIsReturned() {
 441         metaFile =
 442                 "TOSCA-Meta-File-Version: 1.0\n"+
 443                 "CSAR-Version: 1.1\n"+
 444                 "Created-By: Vendor\n"+
 445                 TOSCA_META_ENTRY_DEFINITIONS + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Definitions/MainServiceTemplate.yaml\n"+
 446                 TOSCA_META_ETSI_ENTRY_MANIFEST + ATTRIBUTE_VALUE_SEPARATOR.getToken() +"Definitions/MainServiceTemplate2.mf\n"+
 447                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + ATTRIBUTE_VALUE_SEPARATOR.getToken() +"Artifacts/changeLog.text\n";
 448
 449         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 450
 451         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 452         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 453
 454         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 455         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 456
 457         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 458         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 459
 460         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 461         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 462
 463         manifestBuilder.withSource("Definitions/MainServiceTemplate2.mf");
 464         handler.addFile("Definitions/MainServiceTemplate2.mf", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 465
 466         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 467         assertExpectedErrors("Main TOSCA definitions file and Manifest file with different name should return error",
 468                errors, 1);
 469     }
 470
 471     @Test
 472     public void testGivenManifestFile_withDifferentExtension_thenErrorIsReturned() {
 473         metaFile =
 474                 "TOSCA-Meta-File-Version: 1.0\n"+
 475                 "CSAR-Version: 1.1\n"+
 476                 "Created-By: Vendor\n"+
 477                 "Entry-Definitions: Definitions/MainServiceTemplate.yaml\n"+
 478                 TOSCA_META_ETSI_ENTRY_MANIFEST + ATTRIBUTE_VALUE_SEPARATOR.getToken() +  "Definitions/MainServiceTemplate.txt\n"+
 479                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Artifacts/changeLog.text\n";
 480
 481         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 482
 483         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 484         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 485
 486         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 487         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 488
 489         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 490         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 491
 492         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 493         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 494
 495         manifestBuilder.withSource("Definitions/MainServiceTemplate.txt");
 496         handler.addFile("Definitions/MainServiceTemplate.txt", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 497
 498         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 499         assertExpectedErrors("Manifest file with different extension than .mf should return error",
 500                 errors, 1);
 501     }
 502
 503     @Test
 504     public void testGivenManifestFile_withValidVnfMetadata_thenNoErrorsReturned() {
 505         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 506
 507         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 508         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 509         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 510         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 511         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 512         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 513
 514         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 515         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 516
 517         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 518         assertExpectedErrors("Manifest with valid vnf mandatory values should not return any errors", errors, 0);
 519     }
 520
 521     @Test
 522     public void testGivenManifestFile_withValidPnfMetadata_thenNoErrorsReturned() {
 523         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 524
 525         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 526         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 527
 528         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 529         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 530
 531         manifestBuilder.withSignedSource(TOSCA_DEFINITION_FILEPATH
 532             , "SHA-abc", "09e5a788acb180162c51679ae4c998039fa6644505db2415e35107d1ee213943");
 533         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 534
 535         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 536         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 537
 538         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 539         assertExpectedErrors("Manifest with valid pnf mandatory values should not return any errors", errors, 0);
 540     }
 541
 542     /**
 543      * Manifest with mixed metadata should return error.
 544      */
 545     @Test
 546     public void testGivenManifestFile_withMetadataContainingMixedPnfVnfMetadata_thenErrorIsReturned() {
 547         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 548             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 549             .withMetaData(VNF_PROVIDER_ID.getToken(), "Bilal Iqbal")
 550             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 551             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 552
 553         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 554         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 555         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 556         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 557         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 558         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 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         assertExpectedErrors("Manifest with mixed metadata should return error", errors, 1);
 565     }
 566
 567
 568     @Test
 569     public void testGivenManifestFile_withMetadataMissingPnfOrVnfMandatoryEntries_thenErrorIsReturned() {
 570         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 571             .withMetaData("invalid_product_name", "RadioNode")
 572             .withMetaData("invalid_provider_id", "Bilal Iqbal")
 573             .withMetaData("invalid_package_version", "1.0")
 574             .withMetaData("invalid_release_date_time", "2019-12-14T11:25:00+00:00");
 575
 576         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 577         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 578
 579         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 580         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 581
 582         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 583         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 584
 585         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 586         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 587
 588         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 589         assertExpectedErrors("Manifest with missing vnf or pnf mandatory entries should return error", errors, 1);
 590     }
 591
 592     @Test
 593     public void testGivenManifestFile_withMetadataMissingMandatoryPnfEntries_thenErrorIsReturned() {
 594         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 595
 596         manifestBuilder.withMetaData(PNFD_NAME.getToken(), "RadioNode");
 597         manifestBuilder.withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 598
 599         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 600         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 601
 602         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 603         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 604
 605         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 606         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 607
 608         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 609         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 610
 611         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 612         assertExpectedErrors("Manifest with metadata missing pnf mandatory entries should return error", errors, 1);
 613
 614     }
 615
 616     @Test
 617     public void testGivenManifestFile_withMetadataMissingMandatoryVnfEntries_thenErrorIsReturned() {
 618         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 619
 620         manifestBuilder.withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode");
 621
 622         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 623         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 624
 625         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 626         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 627
 628         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 629         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 630
 631         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 632         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 633
 634         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 635         assertExpectedErrors("Manifest with metadata missing vnf mandatory entries should return error", errors, 1);
 636
 637     }
 638
 639     /**
 640      * Manifest with more than 4 metadata entries should return error.
 641      */
 642     @Test
 643     public void testGivenManifestFile_withMetadataEntriesExceedingTheLimit_thenErrorIsReturned() {
 644         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 645             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 646             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "Bilal Iqbal")
 647             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 648             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 649
 650         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 651         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 652
 653         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 654         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 655
 656         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 657         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 658
 659         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 660         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 661
 662         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 663         assertExpectedErrors("Manifest with more than 4 metadata entries should return error", errors, 1);
 664     }
 665
 666     @Test
 667     public void testGivenManifestFile_withPnfMetadataAndVfEntries_thenErrorIsReturned() {
 668         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 669
 670         metaFile = metaFile +
 671             TOSCA_META_ETSI_ENTRY_TESTS + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Files/Tests\n" +
 672             TOSCA_META_ETSI_ENTRY_LICENSES + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Files/Licenses\n" +
 673             TOSCA_META_ETSI_ENTRY_CERTIFICATE + ATTRIBUTE_VALUE_SEPARATOR.getToken() + "Files/Certificates";
 674
 675         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 676         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 677
 678         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 679         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 680
 681         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 682         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 683
 684         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 685         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 686         handler.addFolder("Files/Certificates/");
 687         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 688         assertExpectedErrors("Tosca.meta should not have entries applicable only to VF", errors, 2);
 689
 690     }
 691
 692     /**
 693      * Tests an imported descriptor with a missing imported file.
 694      */
 695     @Test
 696     public void testGivenDefinitionFileWithImportedDescriptor_whenImportedDescriptorImportsMissingFile_thenMissingImportErrorOccur() {
 697         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 698
 699         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 700         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 701
 702         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 703         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 704
 705         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 706         manifestBuilder.withSource(SAMPLE_SOURCE);
 707
 708         final String definitionImportOne = "Definitions/importOne.yaml";
 709         handler.addFile(definitionImportOne, getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml"));
 710         manifestBuilder.withSource(definitionImportOne);
 711
 712         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithOneImport.yaml";
 713         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 714         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 715
 716         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 717         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 718
 719         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 720
 721         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 722         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 723             , Messages.MISSING_IMPORT_FILE.formatMessage("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml"))
 724         );
 725
 726         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 727     }
 728
 729     /**
 730      * Tests an imported descriptor with invalid import statement.
 731      */
 732     @Test
 733     public void testGivenDefinitionFileWithImportedDescriptor_whenInvalidImportStatementExistInImportedDescriptor_thenInvalidImportErrorOccur() {
 734         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 735
 736         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 737         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 738
 739         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 740         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 741
 742         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 743         manifestBuilder.withSource(SAMPLE_SOURCE);
 744
 745         final String definitionImportOne = "Definitions/importOne.yaml";
 746         handler.addFile(definitionImportOne, getResourceBytes("/validation.files/definition/definitionFileWithInvalidImport.yaml"));
 747         manifestBuilder.withSource(definitionImportOne);
 748
 749         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithOneImport.yaml";
 750         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 751         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 752
 753         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 754         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 755
 756         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 757
 758         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 759         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 760             , Messages.INVALID_IMPORT_STATEMENT.formatMessage(definitionImportOne, "null"))
 761         );
 762
 763         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 764     }
 765
 766     @Test
 767     public void givenManifestWithNonManoPmAndVesArtifacts_whenNonManoArtifactsAreValid_thenNoErrorsOccur() {
 768         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 769
 770         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 771         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 772
 773         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 774         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 775
 776         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 777         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 778
 779         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 780         handler.addFile(nonManoPmEventsSource, getResourceBytes("/validation.files/measurements/pmEvents-valid.yaml"));
 781         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 782
 783         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 784         handler.addFile(nonManoVesEventsSource, getResourceBytes("/validation.files/events/vesEvents-valid.yaml"));
 785         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 786
 787         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 788         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 789
 790         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 791             .validateContent(handler);
 792
 793         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
 794     }
 795
 796     @Test
 797     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreInvalid_thenInvalidYamlErrorOccur() {
 798         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 799
 800         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 801         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 802
 803         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 804         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 805
 806         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 807         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 808
 809         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 810         handler.addFile(nonManoPmEventsSource, getResourceBytes(INVALID_YAML_FILE_PATH));
 811         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 812
 813         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 814         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 815
 816         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 817         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 818             , Messages.INVALID_YAML_FORMAT_1.formatMessage(nonManoPmEventsSource, "while scanning a simple key\n"
 819             + " in 'reader', line 2, column 1:\n"
 820             + "    key {}\n"
 821             + "    ^\n"
 822             + "could not find expected ':'\n"
 823             + " in 'reader', line 2, column 7:\n"
 824             + "    {}\n"
 825             + "      ^\n"))
 826         );
 827
 828         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 829             .validateContent(handler);
 830
 831         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 832     }
 833
 834     @Test
 835     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreEmpty_thenEmptyYamlErrorOccur() {
 836         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 837
 838         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 839         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 840
 841         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 842         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 843
 844         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 845         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 846
 847         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 848         handler.addFile(nonManoPmEventsSource, getResourceBytes(EMPTY_YAML_FILE_PATH));
 849         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 850
 851         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 852         handler.addFile(nonManoVesEventsSource, getResourceBytes(EMPTY_YAML_FILE_PATH));
 853         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 854
 855         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 856         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 857
 858         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 859         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 860             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoPmEventsSource))
 861         );
 862         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 863             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoVesEventsSource))
 864         );
 865
 866         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 867             .validateContent(handler);
 868
 869         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 870     }
 871
 872     @Test
 873     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsHaveNotYamlExtension_thenInvalidYamlExtensionErrorOccur() {
 874         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 875
 876         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 877         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 878
 879         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 880         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 881
 882         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 883         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 884
 885         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.y1";
 886         handler.addFile(nonManoPmEventsSource, "".getBytes());
 887         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 888
 889         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.y2";
 890         handler.addFile(nonManoVesEventsSource, "".getBytes());
 891         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 892
 893         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 894         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 895
 896         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 897         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 898             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoPmEventsSource))
 899         );
 900         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 901             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoVesEventsSource))
 902         );
 903
 904         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 905             .validateContent(handler);
 906
 907         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 908     }
 909
 910     private void assertExpectedErrors(final String testCase, final Map<String, List<ErrorMessage>> errors, final int expectedErrors){
 911         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 912         printErrorMessages(errorMessages);
 913         if (expectedErrors > 0) {
 914             assertEquals(testCase, expectedErrors, errorMessages.size());
 915         } else {
 916             assertEquals(testCase, expectedErrors, errors.size());
 917         }
 918     }
 919
 920     private void printErrorMessages(final List<ErrorMessage> errorMessages) {
 921         if (CollectionUtils.isNotEmpty(errorMessages)) {
 922             errorMessages.forEach(errorMessage ->
 923                 System.out.println(String.format("%s: %s", errorMessage.getLevel(), errorMessage.getMessage()))
 924             );
 925         }
 926     }
 927
 928     private byte[] getResourceBytes(final String resourcePath) {
 929         try {
 930             return ValidatorUtil.getFileResource(resourcePath);
 931         } catch (final IOException e) {
 932             final String errorMsg = String.format("Could not load resource '%s'", resourcePath);
 933             LOGGER.error(errorMsg, e);
 934             fail(errorMsg);
 935         }
 936
 937         return null;
 938     }
 939
 940     private ManifestBuilder getPnfManifestSampleBuilder() {
 941         return new ManifestBuilder()
 942             .withMetaData(PNFD_NAME.getToken(), "myPnf")
 943             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "ACME")
 944             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 945             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 946     }
 947
 948     private ManifestBuilder getVnfManifestSampleBuilder() {
 949         return new ManifestBuilder()
 950             .withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode")
 951             .withMetaData(VNF_PROVIDER_ID.getToken(), "ACME")
 952             .withMetaData(VNF_PACKAGE_VERSION.getToken(), "1.0")
 953             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 954     }
 955
 956     private void assertExpectedErrors(List<ErrorMessage> actualErrorList, final List<ErrorMessage> expectedErrorList) {
 957         if (actualErrorList == null) {
 958             actualErrorList = new ArrayList<>();
 959         }
 960
 961         printErrorMessages(actualErrorList);
 962
 963         assertThat("The actual error list should have the same size as the expected error list"
 964             , actualErrorList, hasSize(expectedErrorList.size())
 965         );
 966
 967         assertThat("The actual error and expected error lists should be the same"
 968             , actualErrorList, containsInAnyOrder(expectedErrorList.toArray(new ErrorMessage[0]))
 969         );
 970     }
 971
 972 }