Allow for predicate based checking of image names

Update `DockerComposeConnectionDetailsFactory` to accept a `Predicate`
based check to determine if the source should be accepted.

The existing name based checks have also been improved to allow names
outside of official docker images. The `ImageReference` and `ImageName`
classes have been mainly copied from
`org.springframework.boot.buildpack.platform.docker.type`.

Closes gh-35154

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/DefaultDockerComposeTests.java

@@ -133,7 +133,7 @@ class DefaultDockerComposeTests {
 		assertThat(runningServices).hasSize(1);
 		RunningService runningService = runningServices.get(0);
 		assertThat(runningService.name()).isEqualTo("name");
-		assertThat(runningService.image()).hasToString("redis");
+		assertThat(runningService.image()).hasToString("docker.io/library/redis");
 		assertThat(runningService.host()).isEqualTo(HOST);
 		assertThat(runningService.ports().getAll()).isEmpty();
 		assertThat(runningService.env()).containsExactly(entry("a", "b"));

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/DefaultRunningServiceTests.java

@@ -77,13 +77,13 @@ class DefaultRunningServiceTests {
 
 	@Test
 	void imageReturnsImageFromPsResponse() {
-		assertThat(this.runningService.image()).hasToString("redis");
+		assertThat(this.runningService.image()).hasToString("docker.io/library/redis");
 	}
 
 	@Test // gh-34992
 	void imageWhenUsingEarlierDockerVersionReturnsImageFromInspectResult() {
 		DefaultRunningService runningService = createRunningService(false);
-		assertThat(runningService.image()).hasToString("redis");
+		assertThat(runningService.image()).hasToString("docker.io/library/redis");
 
 	}
 

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/ImageNameTests.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2012-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.docker.compose.core;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+/**
+ * Tests for {@link ImageName}.
+ *
+ * @author Phillip Webb
+ * @author Scott Frederick
+ */
+class ImageNameTests {
+
+	@Test
+	void ofWhenNameOnlyCreatesImageName() {
+		ImageName imageName = ImageName.of("ubuntu");
+		assertThat(imageName).hasToString("docker.io/library/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("docker.io");
+		assertThat(imageName.getName()).isEqualTo("library/ubuntu");
+	}
+
+	@Test
+	void ofWhenSlashedNameCreatesImageName() {
+		ImageName imageName = ImageName.of("canonical/ubuntu");
+		assertThat(imageName).hasToString("docker.io/canonical/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("docker.io");
+		assertThat(imageName.getName()).isEqualTo("canonical/ubuntu");
+	}
+
+	@Test
+	void ofWhenLocalhostNameCreatesImageName() {
+		ImageName imageName = ImageName.of("localhost/canonical/ubuntu");
+		assertThat(imageName).hasToString("localhost/canonical/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("localhost");
+		assertThat(imageName.getName()).isEqualTo("canonical/ubuntu");
+	}
+
+	@Test
+	void ofWhenDomainAndNameCreatesImageName() {
+		ImageName imageName = ImageName.of("repo.spring.io/canonical/ubuntu");
+		assertThat(imageName).hasToString("repo.spring.io/canonical/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("repo.spring.io");
+		assertThat(imageName.getName()).isEqualTo("canonical/ubuntu");
+	}
+
+	@Test
+	void ofWhenDomainNameAndPortCreatesImageName() {
+		ImageName imageName = ImageName.of("repo.spring.io:8080/canonical/ubuntu");
+		assertThat(imageName).hasToString("repo.spring.io:8080/canonical/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("repo.spring.io:8080");
+		assertThat(imageName.getName()).isEqualTo("canonical/ubuntu");
+	}
+
+	@Test
+	void ofWhenSimpleNameAndPortCreatesImageName() {
+		ImageName imageName = ImageName.of("repo:8080/ubuntu");
+		assertThat(imageName).hasToString("repo:8080/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("repo:8080");
+		assertThat(imageName.getName()).isEqualTo("ubuntu");
+	}
+
+	@Test
+	void ofWhenSimplePathAndPortCreatesImageName() {
+		ImageName imageName = ImageName.of("repo:8080/canonical/ubuntu");
+		assertThat(imageName).hasToString("repo:8080/canonical/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("repo:8080");
+		assertThat(imageName.getName()).isEqualTo("canonical/ubuntu");
+	}
+
+	@Test
+	void ofWhenNameWithLongPathCreatesImageName() {
+		ImageName imageName = ImageName.of("path1/path2/path3/ubuntu");
+		assertThat(imageName).hasToString("docker.io/path1/path2/path3/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("docker.io");
+		assertThat(imageName.getName()).isEqualTo("path1/path2/path3/ubuntu");
+	}
+
+	@Test
+	void ofWhenLocalhostDomainCreatesImageName() {
+		ImageName imageName = ImageName.of("localhost/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("localhost");
+		assertThat(imageName.getName()).isEqualTo("ubuntu");
+	}
+
+	@Test
+	void ofWhenLocalhostDomainAndPathCreatesImageName() {
+		ImageName imageName = ImageName.of("localhost/library/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("localhost");
+		assertThat(imageName.getName()).isEqualTo("library/ubuntu");
+	}
+
+	@Test
+	void ofWhenLegacyDomainUsesNewDomain() {
+		ImageName imageName = ImageName.of("index.docker.io/ubuntu");
+		assertThat(imageName).hasToString("docker.io/library/ubuntu");
+		assertThat(imageName.getDomain()).isEqualTo("docker.io");
+		assertThat(imageName.getName()).isEqualTo("library/ubuntu");
+	}
+
+	@Test
+	void ofWhenNameIsNullThrowsException() {
+		assertThatIllegalArgumentException().isThrownBy(() -> ImageName.of(null))
+			.withMessage("Value must not be empty");
+	}
+
+	@Test
+	void ofWhenNameIsEmptyThrowsException() {
+		assertThatIllegalArgumentException().isThrownBy(() -> ImageName.of("")).withMessage("Value must not be empty");
+	}
+
+	@Test
+	void ofWhenContainsUppercaseThrowsException() {
+		assertThatIllegalArgumentException().isThrownBy(() -> ImageName.of("Test"))
+			.withMessageContaining("Unable to parse name")
+			.withMessageContaining("Test");
+	}
+
+	@Test
+	void ofWhenNameIncludesTagThrowsException() {
+		assertThatIllegalArgumentException().isThrownBy(() -> ImageName.of("ubuntu:latest"))
+			.withMessageContaining("Unable to parse name")
+			.withMessageContaining(":latest");
+	}
+
+	@Test
+	void ofWhenNameIncludeDigestThrowsException() {
+		assertThatIllegalArgumentException().isThrownBy(
+				() -> ImageName.of("ubuntu@sha256:47bfdb88c3ae13e488167607973b7688f69d9e8c142c2045af343ec199649c09"))
+			.withMessageContaining("Unable to parse name")
+			.withMessageContaining("@sha256:47b");
+	}
+
+	@Test
+	void hashCodeAndEquals() {
+		ImageName n1 = ImageName.of("ubuntu");
+		ImageName n2 = ImageName.of("library/ubuntu");
+		ImageName n3 = ImageName.of("docker.io/ubuntu");
+		ImageName n4 = ImageName.of("docker.io/library/ubuntu");
+		ImageName n5 = ImageName.of("index.docker.io/library/ubuntu");
+		ImageName n6 = ImageName.of("alpine");
+		assertThat(n1).hasSameHashCodeAs(n2).hasSameHashCodeAs(n3).hasSameHashCodeAs(n4).hasSameHashCodeAs(n5);
+		assertThat(n1).isEqualTo(n1).isEqualTo(n2).isEqualTo(n3).isEqualTo(n4).isNotEqualTo(n6);
+	}
+
+}

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/core/ImageReferenceTests.java

@@ -19,85 +19,150 @@ package org.springframework.boot.docker.compose.core;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 
 /**
  * Tests for {@link ImageReference}.
  *
- * @author Moritz Halbritter
- * @author Andy Wilkinson
  * @author Phillip Webb
+ * @author Scott Frederick
  */
 class ImageReferenceTests {
 
 	@Test
-	void getImageNameWhenImageOnly() {
-		ImageReference imageReference = ImageReference.of("redis");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofSimpleName() {
+		ImageReference reference = ImageReference.of("ubuntu");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("docker.io/library/ubuntu");
 	}
 
 	@Test
-	void getImageNameWhenImageAndTag() {
-		ImageReference imageReference = ImageReference.of("redis:5");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofLibrarySlashName() {
+		ImageReference reference = ImageReference.of("library/ubuntu");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("docker.io/library/ubuntu");
 	}
 
 	@Test
-	void getImageNameWhenImageAndDigest() {
-		ImageReference imageReference = ImageReference
-			.of("redis@sha256:0ed5d5928d4737458944eb604cc8509e245c3e19d02ad83935398bc4b991aac7");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofSlashName() {
+		ImageReference reference = ImageReference.of("adoptopenjdk/openjdk11");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("adoptopenjdk/openjdk11");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("docker.io/adoptopenjdk/openjdk11");
 	}
 
 	@Test
-	void getImageNameWhenProjectAndImage() {
-		ImageReference imageReference = ImageReference.of("library/redis");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofCustomDomain() {
+		ImageReference reference = ImageReference.of("repo.example.com/java/jdk");
+		assertThat(reference.getDomain()).isEqualTo("repo.example.com");
+		assertThat(reference.getName()).isEqualTo("java/jdk");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("repo.example.com/java/jdk");
 	}
 
 	@Test
-	void getImageNameWhenRegistryLibraryAndImage() {
-		ImageReference imageReference = ImageReference.of("docker.io/library/redis");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofCustomDomainAndPort() {
+		ImageReference reference = ImageReference.of("repo.example.com:8080/java/jdk");
+		assertThat(reference.getDomain()).isEqualTo("repo.example.com:8080");
+		assertThat(reference.getName()).isEqualTo("java/jdk");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("repo.example.com:8080/java/jdk");
 	}
 
 	@Test
-	void getImageNameWhenRegistryLibraryImageAndTag() {
-		ImageReference imageReference = ImageReference.of("docker.io/library/redis:5");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofLegacyDomain() {
+		ImageReference reference = ImageReference.of("index.docker.io/ubuntu");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("docker.io/library/ubuntu");
 	}
 
 	@Test
-	void getImageNameWhenRegistryLibraryImageAndDigest() {
-		ImageReference imageReference = ImageReference
-			.of("docker.io/library/redis@sha256:0ed5d5928d4737458944eb604cc8509e245c3e19d02ad83935398bc4b991aac7");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofNameAndTag() {
+		ImageReference reference = ImageReference.of("ubuntu:bionic");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isEqualTo("bionic");
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("docker.io/library/ubuntu:bionic");
 	}
 
 	@Test
-	void getImageNameWhenRegistryWithPort() {
-		ImageReference imageReference = ImageReference.of("my_private.registry:5000/redis");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofDomainPortAndTag() {
+		ImageReference reference = ImageReference.of("repo.example.com:8080/library/ubuntu:v1");
+		assertThat(reference.getDomain()).isEqualTo("repo.example.com:8080");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isEqualTo("v1");
+		assertThat(reference.getDigest()).isNull();
+		assertThat(reference).hasToString("repo.example.com:8080/library/ubuntu:v1");
 	}
 
 	@Test
-	void getImageNameWhenRegistryWithPortAndTag() {
-		ImageReference imageReference = ImageReference.of("my_private.registry:5000/redis:5");
-		assertThat(imageReference.getImageName()).isEqualTo("redis");
+	void ofNameAndDigest() {
+		ImageReference reference = ImageReference
+			.of("ubuntu@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isNull();
+		assertThat(reference.getDigest())
+			.isEqualTo("sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference).hasToString(
+				"docker.io/library/ubuntu@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
 	}
 
 	@Test
-	void toStringReturnsReferenceString() {
-		ImageReference imageReference = ImageReference.of("docker.io/library/redis");
-		assertThat(imageReference).hasToString("docker.io/library/redis");
+	void ofNameAndTagAndDigest() {
+		ImageReference reference = ImageReference
+			.of("ubuntu:bionic@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference.getDomain()).isEqualTo("docker.io");
+		assertThat(reference.getName()).isEqualTo("library/ubuntu");
+		assertThat(reference.getTag()).isEqualTo("bionic");
+		assertThat(reference.getDigest())
+			.isEqualTo("sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference).hasToString(
+				"docker.io/library/ubuntu:bionic@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+	}
+
+	@Test
+	void ofCustomDomainAndPortWithTag() {
+		ImageReference reference = ImageReference
+			.of("example.com:8080/canonical/ubuntu:bionic@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference.getDomain()).isEqualTo("example.com:8080");
+		assertThat(reference.getName()).isEqualTo("canonical/ubuntu");
+		assertThat(reference.getTag()).isEqualTo("bionic");
+		assertThat(reference.getDigest())
+			.isEqualTo("sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+		assertThat(reference).hasToString(
+				"example.com:8080/canonical/ubuntu:bionic@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d");
+	}
+
+	@Test
+	void ofWhenHasIllegalCharacter() {
+		assertThatIllegalArgumentException()
+			.isThrownBy(() -> ImageReference
+				.of("registry.example.com/example/example-app:1.6.0-dev.2.uncommitted+wip.foo.c75795d"))
+			.withMessageContaining("Unable to parse image reference");
 	}
 
 	@Test
 	void equalsAndHashCode() {
-		ImageReference imageReference1 = ImageReference.of("docker.io/library/redis");
-		ImageReference imageReference2 = ImageReference.of("docker.io/library/redis");
-		ImageReference imageReference3 = ImageReference.of("docker.io/library/other");
-		assertThat(imageReference1.hashCode()).isEqualTo(imageReference2.hashCode());
-		assertThat(imageReference1).isEqualTo(imageReference1).isEqualTo(imageReference2).isNotEqualTo(imageReference3);
+		ImageReference r1 = ImageReference.of("ubuntu:bionic");
+		ImageReference r2 = ImageReference.of("docker.io/library/ubuntu:bionic");
+		ImageReference r3 = ImageReference.of("docker.io/library/ubuntu:latest");
+		assertThat(r1).hasSameHashCodeAs(r2);
+		assertThat(r1).isEqualTo(r1).isEqualTo(r2).isNotEqualTo(r3);
 	}
 
 }

spring-boot-project/spring-boot-docker-compose/src/test/java/org/springframework/boot/docker/compose/service/connection/ConnectionNamePredicateTests.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2012-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.docker.compose.service.connection;
+
+import java.util.Map;
+import java.util.function.Predicate;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.docker.compose.core.ImageReference;
+import org.springframework.boot.docker.compose.core.RunningService;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Tests for {@link ConnectionNamePredicate}.
+ *
+ * @author Phillip Webb
+ */
+class ConnectionNamePredicateTests {
+
+	@Test
+	void offical() {
+		assertThat(predicateOf("elasticsearch")).accepts(sourceOf("elasticsearch"));
+		assertThat(predicateOf("elasticsearch")).accepts(sourceOf("library/elasticsearch"));
+		assertThat(predicateOf("elasticsearch")).accepts(sourceOf("docker.io/library/elasticsearch"));
+		assertThat(predicateOf("elasticsearch")).accepts(sourceOf("docker.io/elasticsearch"));
+		assertThat(predicateOf("elasticsearch")).accepts(sourceOf("docker.io/elasticsearch:latest"));
+		assertThat(predicateOf("elasticsearch")).rejects(sourceOf("redis"));
+		assertThat(predicateOf("elasticsearch")).rejects(sourceOf("library/redis"));
+		assertThat(predicateOf("elasticsearch")).rejects(sourceOf("docker.io/library/redis"));
+		assertThat(predicateOf("elasticsearch")).rejects(sourceOf("docker.io/redis"));
+		assertThat(predicateOf("elasticsearch")).rejects(sourceOf("docker.io/redis"));
+		assertThat(predicateOf("zipkin")).rejects(sourceOf("openzipkin/zipkin"));
+	}
+
+	@Test
+	void organization() {
+		assertThat(predicateOf("openzipkin/zipkin")).accepts(sourceOf("openzipkin/zipkin"));
+		assertThat(predicateOf("openzipkin/zipkin")).accepts(sourceOf("openzipkin/zipkin:latest"));
+		assertThat(predicateOf("openzipkin/zipkin")).rejects(sourceOf("openzipkin/zapkin"));
+		assertThat(predicateOf("openzipkin/zipkin")).rejects(sourceOf("zipkin"));
+	}
+
+	@Test
+	void customDomain() {
+		assertThat(predicateOf("redis")).accepts(sourceOf("internalhost:8080/library/redis"));
+		assertThat(predicateOf("redis")).accepts(sourceOf("myhost.com/library/redis"));
+		assertThat(predicateOf("redis")).accepts(sourceOf("myhost.com:8080/library/redis"));
+		assertThat(predicateOf("redis")).rejects(sourceOf("internalhost:8080/redis"));
+	}
+
+	@Test
+	void labeled() {
+		assertThat(predicateOf("redis")).accepts(sourceOf("internalhost:8080/myredis", "redis"));
+		assertThat(predicateOf("redis")).accepts(sourceOf("internalhost:8080/myredis", "library/redis"));
+		assertThat(predicateOf("openzipkin/zipkin"))
+			.accepts(sourceOf("internalhost:8080/libs/libs/mzipkin", "openzipkin/zipkin"));
+	}
+
+	private Predicate<DockerComposeConnectionSource> predicateOf(String required) {
+		return new ConnectionNamePredicate(required);
+	}
+
+	private DockerComposeConnectionSource sourceOf(String connectioName) {
+		return sourceOf(connectioName, null);
+	}
+
+	private DockerComposeConnectionSource sourceOf(String connectioName, String label) {
+		DockerComposeConnectionSource source = mock(DockerComposeConnectionSource.class);
+		RunningService runningService = mock(RunningService.class);
+		given(source.getRunningService()).willReturn(runningService);
+		given(runningService.image()).willReturn(ImageReference.of(connectioName));
+		if (label != null) {
+			given(runningService.labels()).willReturn(Map.of("org.springframework.boot.service-connection", label));
+		}
+		return source;
+	}
+
+}