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