fix(wait): no port to wait for (testcontainers#3158)

Fix a race condition when processing HostPortStrategy.WaitUntilReady
which could result in it returning "no port to wait for" when no port
is specified as is the case for ForExposedPort.

This could happen if the call happens very quickly after the container
is started and the port is not yet available.

We now retry the internal port detection until found or the internal
context is cancelled.

Fixes: testcontainers#2945

Author: stevenh

wait/host_port.go

@@ -95,6 +95,25 @@ func (hp *HostPortStrategy) Timeout() *time.Duration {
 	return hp.timeout
 }
 
+// detectInternalPort returns the lowest internal port that is currently bound.
+// If no internal port is found, it returns the zero nat.Port value which
+// can be checked against an empty string.
+func (hp *HostPortStrategy) detectInternalPort(ctx context.Context, target StrategyTarget) (nat.Port, error) {
+	var internalPort nat.Port
+	inspect, err := target.Inspect(ctx)
+	if err != nil {
+		return internalPort, fmt.Errorf("inspect: %w", err)
+	}
+
+	for port := range inspect.NetworkSettings.Ports {
+		if internalPort == "" || port.Int() < internalPort.Int() {
+			internalPort = port
+		}
+	}
+
+	return internalPort, nil
+}
+
 // WaitUntilReady implements Strategy.WaitUntilReady
 func (hp *HostPortStrategy) WaitUntilReady(ctx context.Context, target StrategyTarget) error {
 	timeout := defaultStartupTimeout()
@@ -113,26 +132,34 @@ func (hp *HostPortStrategy) WaitUntilReady(ctx context.Context, target StrategyT
 	waitInterval := hp.PollInterval
 
 	internalPort := hp.Port
+	i := 0
 	if internalPort == "" {
-		inspect, err := target.Inspect(ctx)
+		// Port is not specified, so we need to detect it.
+		internalPort, err = hp.detectInternalPort(ctx, target)
 		if err != nil {
-			return err
+			return fmt.Errorf("detect internal port: %w", err)
 		}
 
-		for port := range inspect.NetworkSettings.Ports {
-			if internalPort == "" || port.Int() < internalPort.Int() {
-				internalPort = port
+		for internalPort == "" {
+			select {
+			case <-ctx.Done():
+				return fmt.Errorf("detect internal port: retries: %d, last err: %w, ctx err: %w", i, err, ctx.Err())
+			case <-time.After(waitInterval):
+				if err := checkTarget(ctx, target); err != nil {
+					return fmt.Errorf("detect internal port: check target: retries: %d, last err: %w", i, err)
+				}
+
+				internalPort, err = hp.detectInternalPort(ctx, target)
+				if err != nil {
+					return fmt.Errorf("detect internal port: %w", err)
+				}
 			}
 		}
 	}
 
-	if internalPort == "" {
-		return errors.New("no port to wait for")
-	}
-
 	var port nat.Port
 	port, err = target.MappedPort(ctx, internalPort)
-	i := 0
+	i = 0
 
 	for port == "" {
 		i++
@@ -142,7 +169,7 @@ func (hp *HostPortStrategy) WaitUntilReady(ctx context.Context, target StrategyT
 			return fmt.Errorf("mapped port: retries: %d, port: %q, last err: %w, ctx err: %w", i, port, err, ctx.Err())
 		case <-time.After(waitInterval):
 			if err := checkTarget(ctx, target); err != nil {
-				return fmt.Errorf("check target: retries: %d, port: %q, last err: %w", i, port, err)
+				return fmt.Errorf("mapped port: check target: retries: %d, port: %q, last err: %w", i, port, err)
 			}
 			port, err = target.MappedPort(ctx, internalPort)
 			if err != nil {

wait/host_port_test.go

@@ -70,12 +70,24 @@ func TestWaitForExposedPortSucceeds(t *testing.T) {
 	port, err := nat.NewPort("tcp", strconv.Itoa(rawPort))
 	require.NoError(t, err)
 
-	var mappedPortCount, execCount int
+	var inspectCount, mappedPortCount, execCount int
 	target := &MockStrategyTarget{
 		HostImpl: func(_ context.Context) (string, error) {
 			return "localhost", nil
 		},
 		InspectImpl: func(_ context.Context) (*container.InspectResponse, error) {
+			defer func() { inspectCount++ }()
+			if inspectCount == 0 {
+				// Simulate a container that hasn't bound any ports yet.
+				return &container.InspectResponse{
+					NetworkSettings: &container.NetworkSettings{
+						NetworkSettingsBase: container.NetworkSettingsBase{
+							Ports: nat.PortMap{},
+						},
+					},
+				}, nil
+			}
+
 			return &container.InspectResponse{
 				NetworkSettings: &container.NetworkSettings{
 					NetworkSettingsBase: container.NetworkSettingsBase{