Support SHA256 digest lookup in local image cache

Index images by their repoDigests in addition to repoTags when
populating LocalImagesCache so that digest-based image references
(e.g. alpine@sha256:...) resolve from cache without requiring an
extra inspectImageCmd call.

Closes #1406

Author: konstantinosGkilas

core/src/main/java/org/testcontainers/images/LocalImagesCache.java

@@ -14,7 +14,6 @@
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 @Slf4j
@@ -72,20 +71,35 @@ private synchronized boolean maybeInitCache(DockerClient dockerClient) {
 
     private void populateFromList(List<Image> images) {
         for (Image image : images) {
-            String[] repoTags = image.getRepoTags();
-            if (repoTags == null) {
-                log.debug("repoTags is null, skipping image: {}", image);
-                continue;
-            }
+            ImageData imageData = ImageData.from(image);
 
-            cache.putAll(
+            String[] repoTags = image.getRepoTags();
+            if (repoTags != null) {
                 Stream
                     .of(repoTags)
                     // Protection against some edge case where local image repository tags end up with duplicates
                     // making toMap crash at merge time.
                     .distinct()
-                    .collect(Collectors.toMap(DockerImageName::new, it -> ImageData.from(image)))
-            );
+                    .forEach(tag -> cache.put(new DockerImageName(tag), imageData));
+            }
+
+            String[] repoDigests = image.getRepoDigests();
+            if (repoDigests != null) {
+                Stream
+                    .of(repoDigests)
+                    .distinct()
+                    .forEach(digest -> {
+                        try {
+                            cache.put(new DockerImageName(digest), imageData);
+                        } catch (IllegalArgumentException e) {
+                            log.debug("Unable to parse image digest '{}', skipping", digest, e);
+                        }
+                    });
+            }
+
+            if (repoTags == null && repoDigests == null) {
+                log.debug("repoTags and repoDigests are both null, skipping image: {}", image);
+            }
         }
     }
 }

core/src/test/java/org/testcontainers/images/LocalImagesCacheTest.java

@@ -0,0 +1,150 @@
+package org.testcontainers.images;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.dockerjava.api.model.Image;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.utility.DockerImageName;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LocalImagesCacheTest {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    @BeforeEach
+    void setUp() {
+        LocalImagesCache.INSTANCE.cache.clear();
+        LocalImagesCache.INSTANCE.initialized.set(false);
+    }
+
+    @Test
+    void shouldCacheImageByRepoTag() {
+        Image image = createImage(new String[] { "alpine:3.17" }, null, "sha256:aaa111", 1000L);
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache).containsKey(new DockerImageName("alpine:3.17"));
+    }
+
+    @Test
+    void shouldCacheImageByRepoDigest() {
+        Image image = createImage(
+            null,
+            new String[] { "alpine@sha256:1775bebec23e1f3ce486989bfc9ff3c4e951690df84aa9f926497d82f2ffca9d" },
+            "sha256:bbb222",
+            1000L
+        );
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache)
+            .containsKey(
+                new DockerImageName("alpine@sha256:1775bebec23e1f3ce486989bfc9ff3c4e951690df84aa9f926497d82f2ffca9d")
+            );
+    }
+
+    @Test
+    void shouldCacheImageByBothTagAndDigest() {
+        Image image = createImage(
+            new String[] { "alpine:3.17" },
+            new String[] { "alpine@sha256:1775bebec23e1f3ce486989bfc9ff3c4e951690df84aa9f926497d82f2ffca9d" },
+            "sha256:ccc333",
+            1000L
+        );
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache)
+            .containsKey(new DockerImageName("alpine:3.17"))
+            .containsKey(
+                new DockerImageName("alpine@sha256:1775bebec23e1f3ce486989bfc9ff3c4e951690df84aa9f926497d82f2ffca9d")
+            );
+    }
+
+    @Test
+    void shouldSkipImageWithNullTagsAndNullDigests() {
+        Image image = createImage(null, null, "sha256:ddd444", 1000L);
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache).isEmpty();
+    }
+
+    @Test
+    void shouldHandleMultipleDigestsForSameImage() {
+        Image image = createImage(
+            new String[] { "myapp:latest" },
+            new String[] {
+                "myapp@sha256:aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111",
+                "registry.example.com/myapp@sha256:bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222",
+            },
+            "sha256:eee555",
+            1000L
+        );
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache)
+            .containsKey(new DockerImageName("myapp:latest"))
+            .containsKey(
+                new DockerImageName("myapp@sha256:aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111aaaa1111")
+            )
+            .containsKey(
+                new DockerImageName(
+                    "registry.example.com/myapp@sha256:bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222bbbb2222"
+                )
+            );
+    }
+
+    @Test
+    void shouldHandleDuplicateRepoTags() {
+        Image image = createImage(new String[] { "alpine:3.17", "alpine:3.17" }, null, "sha256:fff666", 1000L);
+
+        populateCache(image);
+
+        assertThat(LocalImagesCache.INSTANCE.cache).containsKey(new DockerImageName("alpine:3.17"));
+    }
+
+    @Test
+    void shouldCacheDigestOnlyImageWithoutTags() {
+        Image image = createImage(
+            new String[] { "<none>:<none>" },
+            new String[] { "myrepo@sha256:abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234" },
+            "sha256:ggg777",
+            1000L
+        );
+
+        populateCache(image);
+
+        // The <none>:<none> tag entry may fail to be useful, but the digest entry should be present
+        assertThat(LocalImagesCache.INSTANCE.cache)
+            .containsKey(
+                new DockerImageName("myrepo@sha256:abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234")
+            );
+    }
+
+    private static Image createImage(String[] repoTags, String[] repoDigests, String id, Long created) {
+        Map<String, Object> fields = new HashMap<>();
+        fields.put("RepoTags", repoTags);
+        fields.put("RepoDigests", repoDigests);
+        fields.put("Id", id);
+        fields.put("Created", created);
+        return MAPPER.convertValue(fields, Image.class);
+    }
+
+    private static void populateCache(Image... images) {
+        try {
+            java.lang.reflect.Method method =
+                LocalImagesCache.class.getDeclaredMethod("populateFromList", java.util.List.class);
+            method.setAccessible(true);
+            method.invoke(LocalImagesCache.INSTANCE, Arrays.asList(images));
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to invoke populateFromList", e);
+        }
+    }
+}