Merge pull request #16 from blackducksoftware/ac_refactor_descriptor_parser

Refactor OciManifestorDescriptorParser, add tests for OciManifestorDe…

Author: crowleySynopsys

src/main/java/com/synopsys/integration/blackduck/imageinspector/image/common/ManifestRepoTagMatcher.java

@@ -20,16 +20,31 @@ public class ManifestRepoTagMatcher {
     public Optional<String> findMatch(List<String> manifestRepoTags, String targetRepoTag) {
         logger.debug(String.format("findRepoTag(): specifiedRepoTag: %s", targetRepoTag));
         for (final String repoTag : manifestRepoTags) {
-            logger.trace(String.format("Target repo tag %s; checking %s", targetRepoTag, repoTag));
-            if (StringUtils.compare(repoTag, targetRepoTag) == 0) {
-                logger.trace(String.format("Found the targetRepoTag %s", targetRepoTag));
-                return Optional.of(repoTag);
-            }
-            if (targetRepoTag.endsWith("/" + repoTag)) {
-                logger.trace(String.format("Matched the targetRepoTag %s to %s by ignoring the repository prefix", targetRepoTag, repoTag));
+            if (doesMatch(repoTag, targetRepoTag)) {
                 return Optional.of(repoTag);
             }
         }
         return Optional.empty();
     }
+
+    public Optional<String> findMatch(String manifestRepoTag, String targetRepoTag) {
+        if (doesMatch(manifestRepoTag, targetRepoTag)) {
+            return Optional.of(manifestRepoTag);
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    private boolean doesMatch(String manifestRepoTag, String targetRepoTag) {
+        logger.trace(String.format("Target repo tag %s; checking %s", targetRepoTag, manifestRepoTag));
+        if (StringUtils.compare(manifestRepoTag, targetRepoTag) == 0) {
+            logger.trace(String.format("Found the targetRepoTag %s", targetRepoTag));
+            return true;
+        }
+        if (targetRepoTag.endsWith("/" + manifestRepoTag)) {
+            logger.trace(String.format("Matched the targetRepoTag %s to %s by ignoring the repository prefix", targetRepoTag, manifestRepoTag));
+            return true;
+        }
+        return false;
+    }
 }

src/main/java/com/synopsys/integration/blackduck/imageinspector/image/oci/OciImageDirectoryExtractor.java

@@ -178,13 +178,6 @@ private File findBlob(File blobsDir, String pathToBlob) throws IntegrationExcept
         return blob;
     }
 
-    private String ensurePopulated(String field, String defaultValue) {
-        if (StringUtils.isBlank(field)) {
-            field = defaultValue;
-        }
-        return field;
-    }
-
     private String findImageConfigFilePath(OciImageManifest imageManifest) throws IntegrationException {
         OciDescriptor imageConfig = imageManifest.getConfig();
         if (imageConfig.getMediaType().equals(CONFIG_FILE_MEDIA_TYPE)) {

src/main/java/com/synopsys/integration/blackduck/imageinspector/image/oci/OciManifestDescriptorParser.java

@@ -28,7 +28,7 @@ public OciManifestDescriptorParser(ManifestRepoTagMatcher manifestRepoTagMatcher
 
     public OciDescriptor getManifestDescriptor(OciImageIndex ociImageIndex,
                                                @Nullable String givenRepo, @Nullable String givenTag) throws IntegrationException {
-        // Probably also need to select one of multiple based on arch
+        // TODO- Probably also need to select one of multiple based on arch
         List<OciDescriptor> trueManifests =
                 ociImageIndex.getManifests().stream()
                         .filter(man -> MANIFEST_FILE_MEDIA_TYPE.equals(man.getMediaType()))
@@ -42,32 +42,16 @@ public OciDescriptor getManifestDescriptor(OciImageIndex ociImageIndex,
         if (StringUtils.isBlank(givenTag)) {
             givenTag = "latest";
         }
-        // Both repo and tag have values
+        // Safe to assume both repo and tag have values
         String givenRepoTag = String.format("%s:%s", givenRepo, givenTag);
 
-        // TODO is there a simpler way to do this?
-        List <String> manifestRepTagStrings = trueManifests.stream()
-                .map(OciDescriptor::getRepoTagString)
-                .filter(Optional::isPresent)
-                .map(Optional::get)
-                .collect(Collectors.toList());
-        Optional<String> matchingManifestRepoTagString = manifestRepoTagMatcher.findMatch(manifestRepTagStrings, givenRepoTag);
-        if (!matchingManifestRepoTagString.isPresent()) {
-            throw new IntegrationException(String.format("No manifest found matching given repo:tag: %s", givenRepoTag));
-        }
-        // We know which repo:tag we want; return manifest matching that
         Optional<OciDescriptor> matchingManifest = trueManifests.stream()
-                .filter(m -> m.getRepoTagString().isPresent())
-                .filter(m -> m.getRepoTagString().get().equals(matchingManifestRepoTagString.get()))
-                .findFirst();
+                                                       .filter(m -> m.getRepoTagString().isPresent())
+                                                       .filter(m -> manifestRepoTagMatcher.findMatch(m.getRepoTagString().get(), givenRepoTag).isPresent())
+                                                       .findFirst();
         if (!matchingManifest.isPresent()) {
-            throw new IntegrationException(String.format("Unable to find manifest matching repo:tag: %s", matchingManifestRepoTagString.get()));
+            throw new IntegrationException(String.format("Unable to find manifest matching repo:tag: %s", givenRepoTag));
         }
         return matchingManifest.get();
     }
-
-    public String getManifestFileDigest(OciImageIndex ociImageIndex,
-                                        @Nullable String givenRepo, @Nullable String givenTag) throws IntegrationException {
-        return getManifestDescriptor(ociImageIndex, givenRepo, givenTag).getDigest();
-    }
 }

src/main/java/com/synopsys/integration/blackduck/imageinspector/image/oci/model/OciDescriptor.java

@@ -29,10 +29,11 @@ public class OciDescriptor {
     @SerializedName("annotations")
     private Map<String, String> annotations;
 
-    public OciDescriptor(final String mediaType, final String digest, final String size) {
+    public OciDescriptor(final String mediaType, final String digest, final String size, final Map<String, String> annotations) {
         this.mediaType = mediaType;
         this.digest = digest;
         this.size = size;
+        this.annotations = annotations;
     }
 
     public String getMediaType() {

src/test/java/com/synopsys/integration/blackduck/imageinspector/image/common/ManifestRepoTagMatcherTest.java

@@ -0,0 +1,28 @@
+package com.synopsys.integration.blackduck.imageinspector.image.common;
+
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class ManifestRepoTagMatcherTest {
+    @ParameterizedTest
+    @MethodSource("testFindMatchProvider")
+    public void testFindMatch(String manifestRepoTag, String targetRepoTag, boolean matches) {
+        ManifestRepoTagMatcher matcher = new ManifestRepoTagMatcher();
+        Assertions.assertEquals(matches, matcher.findMatch(manifestRepoTag, targetRepoTag).isPresent());
+    }
+
+    private static Stream<Arguments> testFindMatchProvider() {
+        return Stream.of(
+            arguments("repo:tag", "org/repo:tag", true),
+            arguments("repo:tag", "repo:tag", true),
+            arguments("org/repo", "repo:tag", false),
+            arguments("org/repo:tag", "repo:tag", false) //TODO- should this be expected?
+        );
+    }
+}

src/test/java/com/synopsys/integration/blackduck/imageinspector/image/oci/OciImageIndexFileParserTest.java

@@ -26,7 +26,7 @@ void testManifestDigest() throws IntegrationException {
         // TODO this test is now cluttered / testing different classes
         // TODO need a test class for OciManifestDescriptorParser
         OciManifestDescriptorParser ociManifestDescriptorParser = new OciManifestDescriptorParser(new ManifestRepoTagMatcher());
-        String manifestDigest = ociManifestDescriptorParser.getManifestFileDigest(ociImageIndex, "", "");
+        String manifestDigest = ociManifestDescriptorParser.getManifestDescriptor(ociImageIndex, "", "").getDigest();
         //assertEquals(1, ociImageIndex.getManifests().size());
         //String manifestDigest = ociImageIndexFileParser.parseManifestFileDigestFromImageIndex(ociImageIndex);
         assertEquals("sha256:8bd1d67ebe6aeae405d824c21560ec9aa2371ed48aa0c4a833e4672cadb0cf3e", manifestDigest);

src/test/java/com/synopsys/integration/blackduck/imageinspector/image/oci/OciManifestDescriptorParserTest.java

@@ -0,0 +1,48 @@
+package com.synopsys.integration.blackduck.imageinspector.image.oci;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.synopsys.integration.blackduck.imageinspector.image.common.ManifestRepoTagMatcher;
+import com.synopsys.integration.blackduck.imageinspector.image.oci.model.OciDescriptor;
+import com.synopsys.integration.blackduck.imageinspector.image.oci.model.OciImageIndex;
+import com.synopsys.integration.exception.IntegrationException;
+
+public class OciManifestDescriptorParserTest {
+    String manifestMediaType = "application/vnd.oci.image.manifest.v1+json";
+
+    @Test
+    public void testFindMatchingManifest() throws IntegrationException {
+        Map<String, String> annotations1 = new HashMap<>();
+        annotations1.put("org.opencontainers.image.ref.name", "repo:tag");
+        annotations1.put("dummy", "dummy");
+        OciDescriptor manifest1 = new OciDescriptor(manifestMediaType, "", "", annotations1);
+
+        Map<String, String> annotations2 = new HashMap<>();
+        annotations2.put("org.opencontainers.image.ref.name", "tag:repo");
+        OciDescriptor manifest2 = new OciDescriptor(manifestMediaType, "", "", annotations2);
+
+        OciDescriptor manifest3 = new OciDescriptor(manifestMediaType, "", "", null);
+
+        List<OciDescriptor> manifests = Arrays.asList(manifest1, manifest2, manifest3);
+        OciImageIndex ociImageIndex = new OciImageIndex(manifests);
+
+        OciManifestDescriptorParser parser = new OciManifestDescriptorParser(new ManifestRepoTagMatcher());
+        Assertions.assertEquals(manifest1, parser.getManifestDescriptor(ociImageIndex, "repo", "tag"));
+    }
+
+    @Test
+    public void testThrowsExceptionWhenNoMatchingManifests() {
+        List<OciDescriptor> manifests = Arrays.asList(
+            new OciDescriptor(manifestMediaType, "", "", new HashMap<>())
+        );
+        OciImageIndex ociImageIndex = new OciImageIndex(manifests);
+        OciManifestDescriptorParser parser = new OciManifestDescriptorParser(new ManifestRepoTagMatcher());
+        Assertions.assertThrows(IntegrationException.class, () -> parser.getManifestDescriptor(ociImageIndex, "repo", "tag"));
+    }
+}