tests: add test cases for the read deadlines

Author: rphillips

image/docker/body_reader_test.go

@@ -2,7 +2,9 @@ package docker
 
 import (
 	"errors"
+	"fmt"
 	"math"
+	"net"
 	"net/http"
 	"testing"
 	"time"
@@ -12,6 +14,67 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// timeoutError implements net.Error with Timeout() returning true.
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return false }
+
+// nonTimeoutNetError implements net.Error with Timeout() returning false.
+type nonTimeoutNetError struct{}
+
+func (e *nonTimeoutNetError) Error() string   { return "non-timeout net error" }
+func (e *nonTimeoutNetError) Timeout() bool   { return false }
+func (e *nonTimeoutNetError) Temporary() bool { return false }
+
+func TestIsRetryableNetworkError(t *testing.T) {
+	for _, c := range []struct {
+		name     string
+		err      error
+		expected bool
+	}{
+		{
+			// A direct timeout error from the network layer should be retryable.
+			name:     "net.Error with Timeout() true",
+			err:      &timeoutError{},
+			expected: true,
+		},
+		{
+			// Timeout errors wrapped by fmt.Errorf should still be detected
+			// via errors.As unwrapping.
+			name:     "wrapped net.Error with Timeout() true",
+			err:      fmt.Errorf("read failed: %w", &timeoutError{}),
+			expected: true,
+		},
+		{
+			// A net.Error that is not a timeout (e.g. a connection refused)
+			// should not be retryable.
+			name:     "net.Error with Timeout() false",
+			err:      &nonTimeoutNetError{},
+			expected: false,
+		},
+		{
+			// A plain error with no net.Error in the chain should not be retryable.
+			name:     "plain error",
+			err:      errors.New("something broke"),
+			expected: false,
+		},
+		{
+			// net.OpError is the concrete type returned by real socket operations;
+			// verify that errors.As can unwrap through it to find the timeout.
+			name:     "net.OpError wrapping timeout",
+			err:      &net.OpError{Op: "read", Err: &timeoutError{}},
+			expected: true,
+		},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			result := isRetryableNetworkError(c.err)
+			assert.Equal(t, c.expected, result)
+		})
+	}
+}
+
 func TestParseDecimalInString(t *testing.T) {
 	for _, prefix := range []string{"", "text", "0"} {
 		for _, suffix := range []string{"", "text"} {

image/docker/docker_client_test.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -20,6 +21,56 @@ import (
 	"go.podman.io/image/v5/types"
 )
 
+// TestDeadlineConnReadTimeout verifies that a stalled connection (no data
+// arriving) returns a timeout error after the configured readTimeout.
+// This is the key behavior that lets bodyReader treat it as a reconnectable
+// condition and resume the download with a Range request.
+func TestDeadlineConnReadTimeout(t *testing.T) {
+	server, client := net.Pipe()
+	defer server.Close()
+	defer client.Close()
+
+	dc := &deadlineConn{
+		Conn:        client,
+		readTimeout: 50 * time.Millisecond,
+	}
+
+	// No data is written to the server side, so the read should time out.
+	buf := make([]byte, 64)
+	_, err := dc.Read(buf)
+	require.Error(t, err)
+
+	// Verify the error satisfies net.Error and reports as a timeout, which
+	// is what isRetryableNetworkError checks.
+	var netErr net.Error
+	require.ErrorAs(t, err, &netErr)
+	assert.True(t, netErr.Timeout(), "expected a timeout error")
+}
+
+// TestDeadlineConnReadSuccess verifies that the deadline wrapper does not
+// interfere with normal reads — when data arrives promptly, it is returned
+// without error.
+func TestDeadlineConnReadSuccess(t *testing.T) {
+	server, client := net.Pipe()
+	defer server.Close()
+	defer client.Close()
+
+	dc := &deadlineConn{
+		Conn:        client,
+		readTimeout: 5 * time.Second,
+	}
+
+	expected := []byte("hello")
+	go func() {
+		_, _ = server.Write(expected)
+	}()
+
+	buf := make([]byte, 64)
+	n, err := dc.Read(buf)
+	require.NoError(t, err)
+	assert.Equal(t, expected, buf[:n])
+}
+
 func TestDockerCertDir(t *testing.T) {
 	const nondefaultFullPath = "/this/is/not/the/default/full/path"
 	const nondefaultPerHostDir = "/this/is/not/the/default/certs.d"