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