Centralize onboarding package validation

Change-Id: I3cc58cf15f62008e83cfc7ddb095d07ab216b82a
Issue-ID: SDC-2583
Signed-off-by: andre.schmid <andre.schmid@est.tech>

4 files changed, 137 insertions, 127 deletions

diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileContentHandler.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileContentHandler.java
index c96ceeb46a..cc13879b96 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileContentHandler.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileContentHandler.java
@@ -21,14 +21,12 @@
 package org.openecomp.core.utilities.file;
 
 import java.io.ByteArrayInputStream;
-import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
-
+import java.util.stream.Collectors;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
 
 public class FileContentHandler {
@@ -36,13 +34,12 @@ public class FileContentHandler {
     private Map<String, byte[]> files = new HashMap<>();
 
     /**
-     * Gets file content.
+     * Gets file content as stream.
      *
      * @param fileName the file name
-     * @return the file content
+     * @return if the file was found, its content as stream, otherwise {@code null}.
      */
-    public InputStream getFileContent(String fileName) {
-
+    public InputStream getFileContentAsStream(final String fileName) {
         byte[] content = files.get(fileName);
         if (content == null || content.length == 0) {
             return null;
@@ -51,89 +48,70 @@ public class FileContentHandler {
         return new ByteArrayInputStream(content);
     }
 
-    /**
-     * Applies a business logic to a file's content while taking care of all retrieval logic.
-     *
-     * @param fileName  name of a file inside this content handler.
-     * @param processor the business logic to work on the file's input stream, which may not be set
-     *                  (check the {@link Optional} if no such file can be found
-     * @param <T>       return type, may be {@link java.lang.Void}
-     * @return result produced by the processor
-     */
-    public <T> T processFileContent(String fileName, Function<Optional<InputStream>, T> processor) {
+    public byte[] getFileContent(final String fileName) {
+        return files.get(fileName);
+    }
 
-        // do not throw IOException to mimic the existing uses of getFileContent()
-        try (InputStream contentInputStream = getFileContent(fileName)) {
-            return processor.apply(Optional.ofNullable(contentInputStream));
-        } catch (IOException e) {
-            throw new ProcessingException("Failed to process file: " + fileName, e);
-        }
+    public boolean isFolder(final String fileName) {
+        return files.get(fileName) == null;
     }
 
-    public void addFile(String fileName, byte[] content) {
-        files.put(fileName, content);
+    public boolean isFile(final String fileName) {
+        return files.get(fileName) != null;
     }
 
-    public void addFile(String fileName, InputStream is) {
+    public void addFolder(final String folder) {
+        files.put(folder, null);
+    }
+
+    public void addFile(final String fileName, final byte[] content) {
+        files.put(fileName, content == null ? new byte[0] : content);
+    }
 
+    public void addFile(final String fileName, final InputStream is) {
         files.put(fileName, FileUtils.toByteArray(is));
     }
 
     public Map<String, byte[]> getFiles() {
-        return files;
+        return files.entrySet().stream().filter(entry -> entry.getValue() != null)
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
-    public void setFiles(Map<String, byte[]> files) {
-        this.files = files;
+    public void setFiles(final Map<String, byte[]> files) {
+        addAll(files);
     }
 
-    public void setFiles(FileContentHandler extFiles) {
-        extFiles.getFileList().forEach(fileName -> this.addFile(fileName, extFiles.getFileContent(fileName)));
+    public Set<String> getFileList() {
+        return files.keySet().stream().filter(this::isFile).collect(Collectors.toSet());
     }
 
-    public Set<String> getFileList() {
-        return files.keySet();
+    public Set<String> getFolderList() {
+        return files.keySet().stream().filter(this::isFolder).collect(Collectors.toSet());
     }
 
-    public void putAll(Map<String, byte[]> files) {
-        this.files = files;
+    public void addAll(final FileContentHandler fileContentHandlerOther) {
+        if (CollectionUtils.isNotEmpty(fileContentHandlerOther.getFolderList())) {
+            fileContentHandlerOther.getFolderList().forEach(this::addFolder);
+        }
+        addAll(fileContentHandlerOther.getFiles());
     }
 
-    public void addAll(FileContentHandler other) {
-        this.files.putAll(other.files);
+    private void addAll(final Map<String, byte[]> files) {
+        if (!MapUtils.isEmpty(files)) {
+            files.forEach(this::addFile);
+        }
     }
 
     public boolean isEmpty() {
         return MapUtils.isEmpty(this.files);
     }
 
-    public void remove(String fileName) {
-        files.remove(fileName);
+    public byte[] remove(final String fileName) {
+        return files.remove(fileName);
     }
 
-    public boolean containsFile(String fileName) {
+    public boolean containsFile(final String fileName) {
         return files.containsKey(fileName);
     }
 
-    /**
-     * An application-specific runtime exception
-     */
-    private static class ProcessingException extends RuntimeException {
-
-        public ProcessingException() {
-            super();
-        }
-
-        public ProcessingException(String message) {
-            super(message);
-        }
-
-        public ProcessingException(Throwable cause) {
-            super(cause);
-        }
-
-        public ProcessingException(String msg, Throwable cause) {
-            super(msg, cause);
-        }
-    }
 }
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileUtils.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileUtils.java
index 31338dcda4..f69a2a060a 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileUtils.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/file/FileUtils.java
@@ -229,9 +229,15 @@ public class FileUtils {
   public static FileContentHandler getFileContentMapFromZip(byte[] zipData)
       throws ZipException {
     final Map<String, byte[]> zipFileAndByteMap = ZipUtils.readZip(zipData, true);
-    final FileContentHandler mapFileContent = new FileContentHandler();
-    mapFileContent.setFiles(zipFileAndByteMap);
-    return mapFileContent;
+    final FileContentHandler fileContentHandler = new FileContentHandler();
+    zipFileAndByteMap.forEach((path, bytes) -> {
+      if (bytes == null) {
+        fileContentHandler.addFolder(path);
+      } else {
+        fileContentHandler.addFile(path, bytes);
+      }
+    });
+    return fileContentHandler;
   }
 
 
@@ -280,24 +286,23 @@ public class FileUtils {
    */
   public static Map<String, String> writeFilesFromFileContentHandler(final FileContentHandler fileContentHandler,
                                                                      final Path dir) throws IOException {
-    File file;
     final File dirFile = dir.toFile();
     final Map<String, String> filePaths = new HashMap<>();
+    File file;
+    for (final String folderPath : fileContentHandler.getFolderList()) {
+      file = new File(dirFile, folderPath);
+      filePaths.put(folderPath, file.getAbsolutePath());
+      if (!file.exists() && !file.mkdirs()) {
+        throw new IOException("Could not create directory " + file.getAbsolutePath());
+      }
+    }
     for (final Map.Entry<String, byte[]> fileEntry : fileContentHandler.getFiles().entrySet()) {
       file = new File(dirFile, fileEntry.getKey());
       filePaths.put(fileEntry.getKey(), file.getAbsolutePath());
       final byte[] fileBytes = fileEntry.getValue();
-      if (fileBytes == null) {
-        if (!file.exists() && !file.mkdirs()) {
-          throw new IOException("Could not create directory " + file.getAbsolutePath());
-        }
-        continue;
-      } else {
-        if (!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
-          throw new IOException("Could not create parent directory for " + file.getAbsolutePath());
-        }
+      if (!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
+        throw new IOException("Could not create parent directory for " + file.getAbsolutePath());
       }
-
       try (final FileOutputStream fop = new FileOutputStream(file.getAbsolutePath());) {
         fop.write(fileBytes);
         fop.flush();
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/orchestration/OnboardingTypesEnum.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/orchestration/OnboardingTypesEnum.java
index 91cbc2c505..1fa96103ab 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/orchestration/OnboardingTypesEnum.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/orchestration/OnboardingTypesEnum.java
@@ -16,14 +16,13 @@
 
 package org.openecomp.core.utilities.orchestration;
 
-import java.util.Optional;
-
-import static java.util.Arrays.asList;
+import java.util.Arrays;
+import org.apache.commons.lang3.StringUtils;
 public enum OnboardingTypesEnum {
-    CSAR("csar"), ZIP("zip"), MANUAL("manual"), NONE("none");
-    private String type;
+    CSAR("csar"), ZIP("zip"), MANUAL("manual"), NONE("none"), SIGNED_CSAR("signed-csar");
+    private final String type;
 
-    OnboardingTypesEnum(String type) {
+    OnboardingTypesEnum(final String type) {
         this.type = type;
     }
 
@@ -32,15 +31,14 @@ public enum OnboardingTypesEnum {
         return type;
     }
 
-    public static final OnboardingTypesEnum getOnboardingTypesEnum(final String inStr) {
-        if (inStr == null) {
+    public static OnboardingTypesEnum getOnboardingTypesEnum(final String type) {
+        if (StringUtils.isEmpty(type)) {
             return null;
         }
 
-        Optional<OnboardingTypesEnum>  onboardingTypesOptional =  asList(OnboardingTypesEnum.values()).stream()
-                .filter(onboardingTypesEnum -> onboardingTypesEnum.toString().equals(inStr.toLowerCase()))
-            .findAny();
-      return onboardingTypesOptional.orElse(null);
+        return Arrays.stream(OnboardingTypesEnum.values())
+            .filter(onboardingTypesEnum -> onboardingTypesEnum.toString().equalsIgnoreCase(type))
+            .findAny().orElse(null);
     }
 
 }
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/test/java/org/openecomp/core/utilities/file/FileContentHandlerTest.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/test/java/org/openecomp/core/utilities/file/FileContentHandlerTest.java
index 0c767a7919..77ada193b3 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/test/java/org/openecomp/core/utilities/file/FileContentHandlerTest.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/test/java/org/openecomp/core/utilities/file/FileContentHandlerTest.java
@@ -16,16 +16,23 @@
 
 package org.openecomp.core.utilities.file;
 
+import static org.hamcrest.Matchers.aMapWithSize;
+import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.Matchers.hasSize;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.AbstractMap;
 import java.util.Arrays;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.junit.Assert;
@@ -48,7 +55,7 @@ public class FileContentHandlerTest {
         Arrays.fill(content, (byte) 44);
         contentHandler.addFile(FILE_NAME, content);
 
-        byte[] actualContent = contentHandler.processFileContent(FILE_NAME, optional -> {
+        byte[] actualContent = processFileContent(FILE_NAME, optional -> {
 
             try {
                 byte[] buffer = new byte[size];
@@ -59,7 +66,7 @@ public class FileContentHandlerTest {
                 throw new RuntimeException("Unexpected error", e);
             }
 
-        });
+        }, contentHandler);
         Assert.assertTrue(Arrays.equals(actualContent, content));
     }
 
@@ -67,13 +74,13 @@ public class FileContentHandlerTest {
     public void testProcessEmptyFileContent() {
         FileContentHandler contentHandler = new FileContentHandler();
         contentHandler.addFile(FILE_NAME, new byte[0]);
-        assertFalse(contentHandler.processFileContent(FILE_NAME, Optional::isPresent));
+        assertFalse(processFileContent(FILE_NAME, Optional::isPresent, contentHandler));
     }
 
     @Test
     public void testProcessNoFileContent() {
         FileContentHandler contentHandler = new FileContentHandler();
-        assertFalse(contentHandler.processFileContent("filename", Optional::isPresent));
+        assertFalse(processFileContent("filename", Optional::isPresent, contentHandler));
     }
 
     @Test
@@ -88,47 +95,69 @@ public class FileContentHandlerTest {
 
     @Test
     public void testSetFiles() {
-        FileContentHandler contentHandler = new FileContentHandler();
-        Map<String, byte[]> fileMap = Stream.of(new AbstractMap.SimpleEntry<>("file1", new byte[0]),
-                    new AbstractMap.SimpleEntry<>("file2", new byte[0]))
-                .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
-
-        contentHandler.setFiles(fileMap);
-
-        Assert.assertEquals(contentHandler.getFiles().size(), 2);
-        Assert.assertEquals(contentHandler.getFileList().size(), 2);
-        assertFalse(contentHandler.isEmpty());
-        contentHandler.remove("file1");
-        assertFalse(contentHandler.containsFile("file1"));
-    }
-
-    @Test
-    public void testAddAll() {
-        FileContentHandler contentHandler = new FileContentHandler();
-        FileContentHandler contentHandler1 = createFileHandlerContent();
-
-        contentHandler.addAll(contentHandler1);
-
-        Assert.assertTrue(contentHandler1.containsFile("file1"));
-        Assert.assertEquals(contentHandler.getFiles().size(), 2);
+        //given
+        final FileContentHandler expectedFileContentHandler = createFileContentHandler();
+        //when
+        final FileContentHandler actualContentHandler = new FileContentHandler();
+        actualContentHandler.setFiles(expectedFileContentHandler.getFiles());
+
+        //then
+        final Map<String, byte[]> actualFileMap = actualContentHandler.getFiles();
+        assertThat("Should contain the expected number of folders", actualContentHandler.getFolderList(), hasSize(0));
+        assertThat("Should contain the expected number of files", actualFileMap, aMapWithSize(2));
+        expectedFileContentHandler.getFiles().keySet().forEach(filePath -> {
+            assertThat("Should contain the expected file", actualFileMap.keySet(), hasItem(filePath));
+        });
     }
 
     @Test
-    public void testSetFilesUsingFIleContentHandlerObject() {
-        FileContentHandler contentHandler1 = createFileHandlerContent();
-
-        FileContentHandler contentHandler = new FileContentHandler();
-        contentHandler.setFiles(contentHandler1);
-
-        Assert.assertEquals(contentHandler.getFiles().size(), 2);
+    public void testAddAllFromFileContentHandler() {
+        //given
+        final FileContentHandler expectedFileContentHandler = createFileContentHandler();
+        //when
+        final FileContentHandler actualContentHandler = new FileContentHandler();
+        actualContentHandler.addAll(expectedFileContentHandler);
+        //then
+        final Map<String, byte[]> actualFileMap = actualContentHandler.getFiles();
+        assertThat("Should contain the expected number of files", actualFileMap, aMapWithSize(2));
+        final Set<String> actualFolderList = actualContentHandler.getFolderList();
+        assertThat("Should contain the expected number of folders", actualFolderList, hasSize(3));
+        expectedFileContentHandler.getFiles().keySet().forEach(filePath -> {
+            assertThat("Should contain the expected file", actualFileMap.keySet(), hasItem(filePath));
+        });
+        expectedFileContentHandler.getFolderList().forEach(folderPath -> {
+            assertThat("Should contain the expected file", actualFolderList, hasItem(folderPath));
+        });
     }
 
-    private FileContentHandler createFileHandlerContent() {
-        FileContentHandler contentHandler1 = new FileContentHandler();
-        Map<String, byte[]> fileMap = Stream.of(new AbstractMap.SimpleEntry<>("file1", new byte[0]),
+    private FileContentHandler createFileContentHandler() {
+        final FileContentHandler contentHandler = new FileContentHandler();
+        final Map<String, byte[]> fileMap = Stream.of(new AbstractMap.SimpleEntry<>("file1", new byte[0]),
                 new AbstractMap.SimpleEntry<>("file2", new byte[0]))
                 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
-        contentHandler1.putAll(fileMap);
-        return contentHandler1;
+        contentHandler.setFiles(fileMap);
+        contentHandler.addFolder("folder1");
+        contentHandler.addFolder("folder1/folder2");
+        contentHandler.addFolder("folder3");
+        return contentHandler;
+    }
+
+    /**
+     * Applies a business logic to a file's content while taking care of all retrieval logic.
+     *
+     * @param fileName  name of a file inside this content handler.
+     * @param processor the business logic to work on the file's input stream, which may not be set
+     *                  (check the {@link Optional} if no such file can be found
+     * @param <T>       return type, may be {@link java.lang.Void}
+     * @return result produced by the processor
+     */
+    public <T> T processFileContent(String fileName, Function<Optional<InputStream>, T> processor, FileContentHandler contentHandler) {
+
+        // do not throw IOException to mimic the existing uses of getFileContent()
+        try (InputStream contentInputStream = contentHandler.getFileContentAsStream(fileName)) {
+            return processor.apply(Optional.ofNullable(contentInputStream));
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to process file: " + fileName, e);
+        }
     }
 }