Skip to content

Modern Docker Management, Designed for Everyone

63.9 KB
Raw Blame
package registry

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"errors"
	"io"
	"log"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strings"
	"testing"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/containerregistry"
	"github.com/google/go-containerregistry/pkg/name"
	"github.com/google/go-containerregistry/pkg/registry"
	"github.com/google/go-containerregistry/pkg/v1"
	"github.com/google/go-containerregistry/pkg/v1/mutate"
	"github.com/google/go-containerregistry/pkg/v1/random"
	"github.com/google/go-containerregistry/pkg/v1/remote"
	"github.com/google/go-containerregistry/pkg/v1/remote/transport"
	"github.com/libtnb/sqlite"
	"github.com/moby/moby/api/pkg/authconfig"
	dockerregistry "github.com/moby/moby/api/types/registry"
	"github.com/moby/moby/client"
	"github.com/opencontainers/go-digest"
	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/sys/crypto"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/kv"
)

type fakeRegistryDaemonClient struct {
	registryLoginFn       func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error)
	distributionInspectFn func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error)
}

func setupContainerRegistryTestDB(t *testing.T) *database.DB {
	t.Helper()

	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&ContainerRegistry{}, &kv.KVEntry{}))
	require.NoError(t, db.Exec("CREATE TABLE IF NOT EXISTS projects (id text PRIMARY KEY, name text, path text)").Error)

	crypto.InitEncryption(&crypto.Config{
		Environment:   "test",
		EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
	})

	return &database.DB{DB: db}
}

func createTestPullRegistry(t *testing.T, db *database.DB, localUrl, username, token string) {
	t.Helper()

	encryptedToken, err := crypto.Encrypt(token)
	require.NoError(t, err)

	record := &ContainerRegistry{
		URL:          localUrl,
		Username:     username,
		Token:        encryptedToken,
		Enabled:      true,
		RegistryType: RegistryTypeGeneric,
	}
	require.NoError(t, db.WithContext(t.Context()).Create(record).Error)
}

func decodeRegistryAuth(t *testing.T, encoded string) dockerregistry.AuthConfig {
	t.Helper()

	cfg, err := authconfig.Decode(encoded)
	require.NoError(t, err)
	return *cfg
}

type roundTripFunc func(*http.Request) (*http.Response, error)

func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
	return f(req)
}

func (f *fakeRegistryDaemonClient) RegistryLogin(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
	if f.registryLoginFn == nil {
		return client.RegistryLoginResult{}, nil
	}
	return f.registryLoginFn(ctx, options)
}

func (f *fakeRegistryDaemonClient) DistributionInspect(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
	if f.distributionInspectFn == nil {
		return client.DistributionInspectResult{}, nil
	}
	return f.distributionInspectFn(ctx, imageRef, options)
}

const dockerHubChallenge = `Bearer realm="https://auth.docker.io/token",service="registry.docker.io"`

// registryPing answers the /v2/ version check every registry client sends first: a bearer challenge when set, else OK.
func registryPing(w http.ResponseWriter, r *http.Request, challenge string) bool {
	if r.URL.Path != "/v2/" {
		return false
	}
	if challenge != "" {
		w.Header().Set("WWW-Authenticate", challenge)
		w.WriteHeader(http.StatusUnauthorized)
		return true
	}
	w.WriteHeader(http.StatusOK)
	return true
}

// writeManifestHead answers a manifest HEAD with the headers a client needs to trust the digest without a body.
func writeManifestHead(w http.ResponseWriter, localDigest string) {
	w.Header().Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
	w.Header().Set("Content-Length", "0")
	w.Header().Set("Docker-Content-Digest", localDigest)
	w.WriteHeader(http.StatusOK)
}

func newDockerHubRateLimitTestClient(t *testing.T, handler http.HandlerFunc) *http.Client {
	t.Helper()

	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if registryPing(w, r, dockerHubChallenge) {
			return
		}
		handler(w, r)
	}))
	t.Cleanup(server.Close)

	targetURL, err := url.Parse(server.URL)
	require.NoError(t, err)

	serverClient := server.Client()
	return &http.Client{
		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
			if req.URL.Host == "registry-1.docker.io" || req.URL.Host == "auth.docker.io" {
				rewritten := req.Clone(req.Context())
				// keep: http.Request is only copyable via Clone
				rewritten.URL.Scheme = targetURL.Scheme
				rewritten.URL.Host = targetURL.Host
				return serverClient.Transport.RoundTrip(rewritten)
			}

			return serverClient.Transport.RoundTrip(req)
		}),
		CheckRedirect: serverClient.CheckRedirect,
		Jar:           serverClient.Jar,
		Timeout:       serverClient.Timeout,
	}
}

func TestNewContainerRegistryService_InitializesDistributionHTTPClient(t *testing.T) {
	svc := NewContainerRegistryService(nil, nil, nil, nil)
	require.NotNil(t, svc.distributionHTTPClient)
}

func TestContainerRegistryService_GetAllRegistryAuthConfigs_NormalizesHosts(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
	createTestPullRegistry(t, db, "https://GHCR.IO/", "gh-user", "gh-token")

	svc := NewContainerRegistryService(db, nil, nil, nil)
	authConfigs, err := svc.GetAllRegistryAuthConfigs(t.Context())
	require.NoError(t, err)
	require.NotNil(t, authConfigs)

	dockerCfg, ok := authConfigs["docker.io"]
	require.True(t, ok)
	assert.Equal(t, "docker-user", dockerCfg.Username)
	assert.Equal(t, "docker-token", dockerCfg.Password)
	assert.Equal(t, "https://index.docker.io/v1/", dockerCfg.ServerAddress)

	assert.Equal(t, dockerCfg, authConfigs["registry-1.docker.io"])
	assert.Equal(t, dockerCfg, authConfigs["index.docker.io"])

	ghcrCfg, ok := authConfigs["ghcr.io"]
	require.True(t, ok)
	assert.Equal(t, "gh-user", ghcrCfg.Username)
	assert.Equal(t, "gh-token", ghcrCfg.Password)
	assert.Equal(t, "ghcr.io", ghcrCfg.ServerAddress)
}

func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://docker.io", "  ", "docker-token")
	createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", "   ")
	createTestPullRegistry(t, db, "https://registry.example.com", "example-user", "example-token")

	svc := NewContainerRegistryService(db, nil, nil, nil)
	authConfigs, err := svc.GetAllRegistryAuthConfigs(t.Context())
	require.NoError(t, err)
	require.NotNil(t, authConfigs)

	assert.NotContains(t, authConfigs, "docker.io")
	assert.NotContains(t, authConfigs, "ghcr.io")

	exampleCfg, ok := authConfigs["registry.example.com"]
	require.True(t, ok)
	assert.Equal(t, "example-user", exampleCfg.Username)
	assert.Equal(t, "example-token", exampleCfg.Password)
	assert.Equal(t, "registry.example.com", exampleCfg.ServerAddress)
}

func TestContainerRegistryService_GetRegistryAuthForImage_UsesDockerHubCredentials(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")

	svc := NewContainerRegistryService(db, nil, nil, nil)
	auth, err := svc.GetRegistryAuthForImage(t.Context(), "nginx:latest")
	require.NoError(t, err)
	require.NotEmpty(t, auth)

	cfg := decodeRegistryAuth(t, auth)
	assert.Equal(t, "docker-user", cfg.Username)
	assert.Equal(t, "docker-token", cfg.Password)
	assert.Equal(t, "https://index.docker.io/v1/", cfg.ServerAddress)
}

func TestContainerRegistryService_GetRegistryAuthForImage_UsesHostLookup(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", "gh-token")

	svc := NewContainerRegistryService(db, nil, nil, nil)
	auth, err := svc.GetRegistryAuthForImage(t.Context(), "ghcr.io/getarcaneapp/arcane:latest")
	require.NoError(t, err)
	require.NotEmpty(t, auth)

	cfg := decodeRegistryAuth(t, auth)
	assert.Equal(t, "gh-user", cfg.Username)
	assert.Equal(t, "gh-token", cfg.Password)
	assert.Equal(t, "ghcr.io", cfg.ServerAddress)
}

func TestContainerRegistryService_NilService_RegistryAuthMethodsReturnEmpty(t *testing.T) {
	var svc *ContainerRegistryService
	ctx := t.Context()

	authConfigs, err := svc.GetAllRegistryAuthConfigs(ctx)
	require.NoError(t, err)
	require.Nil(t, authConfigs)

	authForImage, err := svc.GetRegistryAuthForImage(ctx, "ghcr.io/getarcaneapp/arcane:latest")
	require.NoError(t, err)
	require.Empty(t, authForImage)
}

func TestContainerRegistryService_GetRegistryPullUsage_AnonymousDockerHubLimit(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	require.NoError(t, db.WithContext(t.Context()).Create(&ContainerRegistry{
		URL:          "docker.io",
		Enabled:      true,
		RegistryType: RegistryTypeGeneric,
	}).Error)

	var tokenCalls int

	svc := NewContainerRegistryService(db, nil, kv.NewKVService(db), nil, newDockerHubRateLimitTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/token":
			tokenCalls++
			assert.Empty(t, r.Header.Get("Authorization"))
			_, _ = w.Write([]byte(`{"token":"anonymous-token"}`))
		case r.Method == http.MethodHead && r.URL.Path == "/v2/ratelimitpreview/test/manifests/latest":
			if r.Header.Get("Authorization") != "Bearer anonymous-token" {
				w.Header().Set("WWW-Authenticate", dockerHubChallenge)
				w.WriteHeader(http.StatusUnauthorized)
				return
			}
			w.Header().Set("RateLimit-Limit", "100;w=21600")
			w.Header().Set("RateLimit-Remaining", "90;w=21600")
			w.WriteHeader(http.StatusOK)
		default:
			if !assert.Failf(t, "unexpected failure", "unexpected request %s %s", r.Method, r.URL.Path) {
				return
			}
		}
	}))

	result, err := svc.GetRegistryPullUsage(t.Context())
	require.NoError(t, err)

	require.Len(t, result.Registries, 1)
	registryRecord := result.Registries[0]
	assert.Equal(t, "dockerhub", registryRecord.Provider)
	assert.Equal(t, "anonymous", registryRecord.AuthMethod)
	assert.Empty(t, registryRecord.Error)
	require.NotNil(t, registryRecord.Limit)
	require.NotNil(t, registryRecord.Remaining)
	require.NotNil(t, registryRecord.Used)
	assert.Equal(t, 100, *registryRecord.Limit)
	assert.Equal(t, 90, *registryRecord.Remaining)
	assert.Equal(t, 10, *registryRecord.Used)
	assert.Equal(t, 1, tokenCalls)

	cachedResult, err := svc.GetRegistryPullUsage(t.Context())
	require.NoError(t, err)
	require.Len(t, cachedResult.Registries, 1)
	require.NotNil(t, cachedResult.Registries[0].Remaining)
	assert.Equal(t, 90, *cachedResult.Registries[0].Remaining)
	assert.Equal(t, 1, tokenCalls)
}

func TestContainerRegistryService_GetRegistryPullUsage_UsesDockerHubCredential(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
	createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", "gh-token")

	var tokenAuth string
	svc := NewContainerRegistryService(db, nil, kv.NewKVService(db), nil, newDockerHubRateLimitTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/token":
			tokenAuth = r.Header.Get("Authorization")
			_, _ = w.Write([]byte(`{"token":"credential-token"}`))
		case r.Method == http.MethodHead && r.URL.Path == "/v2/ratelimitpreview/test/manifests/latest":
			if r.Header.Get("Authorization") != "Bearer credential-token" {
				w.Header().Set("WWW-Authenticate", dockerHubChallenge)
				w.WriteHeader(http.StatusUnauthorized)
				return
			}
			w.Header().Set("RateLimit-Limit", "200;w=21600")
			w.Header().Set("RateLimit-Remaining", "199;w=21600")
			w.WriteHeader(http.StatusOK)
		default:
			if !assert.Failf(t, "unexpected failure", "unexpected request %s %s", r.Method, r.URL.Path) {
				return
			}
		}
	}))

	result, err := svc.GetRegistryPullUsage(t.Context())
	require.NoError(t, err)

	require.Len(t, result.Registries, 2)
	registryRecord := result.Registries[0]
	assert.Equal(t, "credential", registryRecord.AuthMethod)
	assert.Equal(t, "docker-user", registryRecord.AuthUsername)
	assert.Empty(t, registryRecord.Error)
	require.NotNil(t, registryRecord.Limit)
	require.NotNil(t, registryRecord.Remaining)
	assert.Equal(t, 200, *registryRecord.Limit)
	assert.Equal(t, 199, *registryRecord.Remaining)
	assert.Contains(t, tokenAuth, "Basic ")
}

func TestContainerRegistryService_GetRegistryPullUsage_CredentialErrorIsNonFatal(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://docker.io", "docker-user", "docker-token")

	svc := NewContainerRegistryService(db, nil, kv.NewKVService(db), nil, newDockerHubRateLimitTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/token":
			w.WriteHeader(http.StatusUnauthorized)
		case r.Method == http.MethodHead && r.URL.Path == "/v2/ratelimitpreview/test/manifests/latest":
			w.Header().Set("WWW-Authenticate", dockerHubChallenge)
			w.WriteHeader(http.StatusUnauthorized)
		default:
			if !assert.Failf(t, "unexpected failure", "unexpected request %s %s", r.Method, r.URL.Path) {
				return
			}
		}
	}))

	result, err := svc.GetRegistryPullUsage(t.Context())
	require.NoError(t, err)

	require.Len(t, result.Registries, 1)
	registryRecord := result.Registries[0]
	assert.Equal(t, "credential", registryRecord.AuthMethod)
	assert.Equal(t, "docker-user", registryRecord.AuthUsername)
	assert.Contains(t, registryRecord.Error, "401 Unauthorized")
}

func TestContainerRegistryService_RecordImagePull_IncrementsObservedRegistryCount(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	require.NoError(t, db.WithContext(t.Context()).Create(&ContainerRegistry{
		URL:          "ghcr.io",
		Enabled:      true,
		RegistryType: RegistryTypeGeneric,
	}).Error)

	svc := NewContainerRegistryService(db, nil, kv.NewKVService(db), nil)
	require.NoError(t, svc.RecordImagePull(t.Context(), "ghcr.io/example/app:latest"))
	require.NoError(t, svc.RecordImagePull(t.Context(), "ghcr.io/example/worker:latest"))

	result, err := svc.GetRegistryPullUsage(t.Context())
	require.NoError(t, err)
	require.Len(t, result.Registries, 1)
	assert.Equal(t, "ghcr.io", result.Registries[0].Registry)
	assert.Equal(t, int64(2), result.Registries[0].ObservedPulls)
	assert.Nil(t, result.Registries[0].Limit)
}

func TestContainerRegistryService_CreateRegistry_RejectsUnsupportedRegistryType(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	_, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:          "registry.example.com",
		RegistryType: "ECR-ish",
	})
	require.Error(t, err)

	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "registryType", fieldErr.Field)
}

func TestContainerRegistryService_CreateRegistry_RejectsEmptyUsernameForGeneric(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	_, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "",
		Token:    "my-token",
	})
	require.Error(t, err)

	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "username", fieldErr.Field)
}

func TestContainerRegistryService_CreateRegistry_RejectsEmptyTokenForGeneric(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	_, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "",
	})
	require.Error(t, err)

	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "token", fieldErr.Field)
}

func TestContainerRegistryService_CreateRegistry_AcceptsValidGenericCredentials(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)
	assert.Equal(t, "my-user", reg.Username)
	assert.NotEmpty(t, reg.Token)
}

func TestContainerRegistryService_UpdateRegistry_RejectsBlankingUsername(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)

	_, err = svc.UpdateRegistry(t.Context(), reg.ID, containerregistry.UpdateContainerRegistryRequest{
		Username: new(""),
	})
	require.Error(t, err)

	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "username", fieldErr.Field)
}

func TestContainerRegistryService_UpdateRegistry_KeepsExistingTokenWhenNotProvided(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)
	originalToken := reg.Token

	updated, err := svc.UpdateRegistry(t.Context(), reg.ID, containerregistry.UpdateContainerRegistryRequest{
		Username: new("updated-user"),
	})
	require.NoError(t, err)
	assert.Equal(t, "updated-user", updated.Username)
	assert.Equal(t, originalToken, updated.Token)
}

func TestContainerRegistryService_UpdateRegistry_RejectsTargetChangeWhenStoredTokenWouldBeReused(t *testing.T) {
	tests := []struct {
		name  string
		token *string
	}{
		{name: "omitted token"},
		{name: "empty token", token: new("")},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			db := setupContainerRegistryTestDB(t)
			svc := NewContainerRegistryService(db, nil, nil, nil)

			registryRecord, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
				URL:      "https://registry.example.com",
				Username: "my-user",
				Token:    "my-token",
			})
			require.NoError(t, err)
			originalToken := registryRecord.Token

			_, err = svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
				URL:   new("https://attacker.example.com"),
				Token: tt.token,
			})
			require.Error(t, err)

			require.ErrorIs(t, err, common.ErrValidation)
			fieldErr, ok := errors.AsType[*base.FieldError](err)
			require.True(t, ok)
			assert.Equal(t, "token", fieldErr.Field)

			stored, loadErr := svc.GetRegistryByID(t.Context(), registryRecord.ID)
			require.NoError(t, loadErr)
			assert.Equal(t, "https://registry.example.com", stored.URL)
			assert.Equal(t, originalToken, stored.Token)
		})
	}
}

func TestContainerRegistryService_UpdateRegistry_AllowsPathChangeOnSameHostWithoutToken(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	registryRecord, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com/one",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)
	originalToken := registryRecord.Token

	updated, err := svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		URL: new("REGISTRY.EXAMPLE.COM/two"),
	})
	require.NoError(t, err)
	assert.Equal(t, "REGISTRY.EXAMPLE.COM/two", updated.URL)
	assert.Equal(t, originalToken, updated.Token)
}

func TestContainerRegistryService_UpdateRegistry_AllowsTargetChangeWhenTokenIsResupplied(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	registryRecord, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)

	updated, err := svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		URL:   new("https://registry.example.net"),
		Token: new("new-token"),
	})
	require.NoError(t, err)
	assert.Equal(t, "https://registry.example.net", updated.URL)

	decryptedToken, decryptErr := crypto.Decrypt(updated.Token)
	require.NoError(t, decryptErr)
	assert.Equal(t, "new-token", decryptedToken)
}

func TestContainerRegistryService_UpdateRegistryRejectsECRTargetChangeWithStoredCredentials(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	registryRecord, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:                "123456789012.dkr.ecr.us-east-1.amazonaws.com",
		RegistryType:       RegistryTypeECR,
		AWSAccessKeyID:     "old-access-key",
		AWSSecretAccessKey: "old-secret-key",
		AWSRegion:          "us-east-1",
	})
	require.NoError(t, err)
	originalSecret := registryRecord.AWSSecretAccessKey

	_, err = svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		URL: new("999999999999.dkr.ecr.us-east-1.amazonaws.com"),
	})
	require.Error(t, err)

	var apiErr *common.APIError
	require.ErrorAs(t, err, &apiErr)
	require.Equal(t, common.APIErrorCodeValidationError, apiErr.Code)
	require.ElementsMatch(t, []string{"awsAccessKeyId", "awsSecretAccessKey"}, apiErr.Details.(map[string]any)["fields"])

	stored, loadErr := svc.GetRegistryByID(t.Context(), registryRecord.ID)
	require.NoError(t, loadErr)
	require.Equal(t, "123456789012.dkr.ecr.us-east-1.amazonaws.com", stored.URL)
	require.Equal(t, originalSecret, stored.AWSSecretAccessKey)

	updated, err := svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		URL:                new("999999999999.dkr.ecr.us-east-1.amazonaws.com"),
		AWSAccessKeyID:     new("new-access-key"),
		AWSSecretAccessKey: new("new-secret-key"),
	})
	require.NoError(t, err)
	require.Equal(t, "999999999999.dkr.ecr.us-east-1.amazonaws.com", updated.URL)

	decryptedSecret, decryptErr := crypto.Decrypt(updated.AWSSecretAccessKey)
	require.NoError(t, decryptErr)
	require.Equal(t, "new-secret-key", decryptedSecret)
}

func TestContainerRegistryService_CreateRegistry_AcceptsECRWithoutKeysForIAMRole(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:          "123456789012.dkr.ecr.us-east-1.amazonaws.com",
		RegistryType: RegistryTypeECR,
		AWSRegion:    "us-east-1",
	})
	require.NoError(t, err)
	assert.Empty(t, reg.AWSAccessKeyID)
	assert.Empty(t, reg.AWSSecretAccessKey)
	assert.Equal(t, "us-east-1", reg.AWSRegion)
}

func TestContainerRegistryService_CreateRegistry_RejectsIncompleteECRKeyPair(t *testing.T) {
	tests := []struct {
		name  string
		keyID string
		key   string
		field string
	}{
		{name: "key id without secret", keyID: "access-key", field: "awsSecretAccessKey"},
		{name: "secret without key id", key: "secret-key", field: "awsAccessKeyId"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			db := setupContainerRegistryTestDB(t)
			svc := NewContainerRegistryService(db, nil, nil, nil)

			_, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
				URL:                "123456789012.dkr.ecr.us-east-1.amazonaws.com",
				RegistryType:       RegistryTypeECR,
				AWSAccessKeyID:     tt.keyID,
				AWSSecretAccessKey: tt.key,
				AWSRegion:          "us-east-1",
			})
			require.ErrorIs(t, err, common.ErrValidation)
			fieldErr, ok := errors.AsType[*base.FieldError](err)
			require.True(t, ok)
			assert.Equal(t, tt.field, fieldErr.Field)
		})
	}
}

func TestContainerRegistryService_UpdateRegistry_ClearingECRKeysSwitchesToIAMRole(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:                "123456789012.dkr.ecr.us-east-1.amazonaws.com",
		RegistryType:       RegistryTypeECR,
		AWSAccessKeyID:     "access-key",
		AWSSecretAccessKey: "secret-key",
		AWSRegion:          "us-east-1",
	})
	require.NoError(t, err)

	require.NoError(t, db.WithContext(t.Context()).Model(reg).Updates(ContainerRegistry{
		ECRToken:            "cached-token",
		ECRTokenGeneratedAt: new(time.Now().UTC()),
	}).Error)

	updated, err := svc.UpdateRegistry(t.Context(), reg.ID, containerregistry.UpdateContainerRegistryRequest{
		AWSAccessKeyID: new(""),
	})
	require.NoError(t, err)
	assert.Empty(t, updated.AWSAccessKeyID)
	assert.Empty(t, updated.AWSSecretAccessKey)
	assert.Empty(t, updated.ECRToken)
	assert.Nil(t, updated.ECRTokenGeneratedAt)
}

func TestContainerRegistryService_SyncRegistries_ClearsECRSecretWhenManagerSendsNoKeys(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	existing, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:                "123456789012.dkr.ecr.us-east-1.amazonaws.com",
		RegistryType:       RegistryTypeECR,
		AWSAccessKeyID:     "access-key",
		AWSSecretAccessKey: "secret-key",
		AWSRegion:          "us-east-1",
	})
	require.NoError(t, err)

	err = svc.SyncRegistries(t.Context(), []containerregistry.Sync{
		{
			ID:           existing.ID,
			URL:          existing.URL,
			Enabled:      true,
			RegistryType: RegistryTypeECR,
			AWSRegion:    "us-east-1",
			CreatedAt:    existing.CreatedAt,
			UpdatedAt:    existing.UpdatedAt,
		},
	})
	require.NoError(t, err)

	var updated ContainerRegistry
	require.NoError(t, db.WithContext(t.Context()).First(&updated, "id = ?", existing.ID).Error)
	assert.Empty(t, updated.AWSAccessKeyID)
	assert.Empty(t, updated.AWSSecretAccessKey)
}

func TestContainerRegistryService_UpdateRegistry_RejectsChangingRegistryType(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)

	_, err = svc.UpdateRegistry(t.Context(), reg.ID, containerregistry.UpdateContainerRegistryRequest{
		RegistryType: new("ecr"),
	})
	require.Error(t, err)

	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "registryType", fieldErr.Field)
}

func TestContainerRegistryService_UpdateRegistry_AllowsSameRegistryType(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	reg, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:      "https://registry.example.com",
		Username: "my-user",
		Token:    "my-token",
	})
	require.NoError(t, err)

	updated, err := svc.UpdateRegistry(t.Context(), reg.ID, containerregistry.UpdateContainerRegistryRequest{
		RegistryType: new("generic"),
		Username:     new("updated-user"),
	})
	require.NoError(t, err)
	assert.Equal(t, "updated-user", updated.Username)
	assert.Equal(t, "generic", updated.RegistryType)
}

func TestContainerRegistryService_SyncRegistries_ClearsGenericTokenWhenManagerSendsEmptyValue(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://registry.example.com", "registry-user", "old-token")

	var existing ContainerRegistry
	require.NoError(t, db.WithContext(t.Context()).First(&existing).Error)

	svc := NewContainerRegistryService(db, nil, nil, nil)
	err := svc.SyncRegistries(t.Context(), []containerregistry.Sync{
		{
			ID:           existing.ID,
			URL:          existing.URL,
			Username:     existing.Username,
			Token:        "",
			Enabled:      true,
			RegistryType: RegistryTypeGeneric,
			CreatedAt:    existing.CreatedAt,
			UpdatedAt:    existing.UpdatedAt,
		},
	})
	require.NoError(t, err)

	var updated ContainerRegistry
	require.NoError(t, db.WithContext(t.Context()).First(&updated, "id = ?", existing.ID).Error)

	decryptedToken, err := crypto.Decrypt(updated.Token)
	require.NoError(t, err)
	assert.Empty(t, decryptedToken)
}

func TestContainerRegistryService_TestRegistry_UsesDockerDaemon(t *testing.T) {
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
				assert.Equal(t, "user", options.Username)
				assert.Equal(t, "token", options.Password)
				assert.Equal(t, "registry.example.com:5443", options.ServerAddress)
				return client.RegistryLoginResult{}, nil
			},
		}, nil
	}, nil, nil)

	err := svc.TestRegistry(t.Context(), "https://registry.example.com:5443", "user", "token")
	require.NoError(t, err)
}

func TestContainerRegistryService_TestRegistry_PropagatesDaemonError(t *testing.T) {
	expectedErr := errors.New("tls: failed to verify certificate: x509: certificate signed by unknown authority")
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
				return client.RegistryLoginResult{}, expectedErr
			},
		}, nil
	}, nil, nil)

	err := svc.TestRegistry(t.Context(), "registry.example.com", "user", "token")
	require.Error(t, err)
	assert.ErrorIs(t, err, expectedErr)
}

func TestContainerRegistryService_TestRegistry_SkipsLoginForEmptyCredentials(t *testing.T) {
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
				require.FailNow(t, "RegistryLogin should not be called with empty credentials")
				return client.RegistryLoginResult{}, nil
			},
		}, nil
	}, nil, nil)

	err := svc.TestRegistry(t.Context(), "registry.example.com", "", "")
	require.NoError(t, err)

	err = svc.TestRegistry(t.Context(), "registry.example.com", "  ", "  ")
	require.NoError(t, err)
}

func TestContainerRegistryService_InspectImageDigest_AnonymousSuccess(t *testing.T) {
	wantDigest := digest.FromString("anonymous-success").String()

	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				assert.Equal(t, "registry.example.com:5443/team/app:1.2.3", imageRef)
				assert.Empty(t, options.EncodedRegistryAuth)
				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "registry.example.com:5443/team/app:1.2.3", nil)
	require.NoError(t, err)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.Equal(t, "registry.example.com:5443", result.AuthRegistry)
}

func TestContainerRegistryService_GetImageDigest_HonorsCallerCancellation(t *testing.T) {
	started := make(chan struct{}, 1)
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, _ string, _ client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				select {
				case started <- struct{}{}:
				default:
				}
				<-ctx.Done()
				return client.DistributionInspectResult{}, ctx.Err()
			},
		}, nil
	}, nil, nil)
	t.Cleanup(svc.cache.StopJanitor)

	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()
	result := make(chan error, 1)
	go func() {
		_, err := svc.ImageDigest(ctx, "registry.example.com/team/app:latest")
		result <- err
	}()

	select {
	case <-started:
	case <-time.After(time.Second):
		require.FailNow(t, "registry lookup did not start")
	}
	cancel()

	select {
	case err := <-result:
		require.ErrorIs(t, err, context.Canceled)
	case <-time.After(time.Second):
		require.FailNow(t, "registry lookup did not honor caller cancellation")
	}
}

func TestContainerRegistryService_InspectImageDigest_UsesStoredDockerHubCredentialsOnFirstAttempt(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
	wantDigest := digest.FromString("stored-credentials").String()

	var calls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				calls++
				assert.Equal(t, "docker.io/library/nginx:latest", imageRef)

				authCfg := decodeRegistryAuth(t, options.EncodedRegistryAuth)
				assert.Equal(t, "docker-user", authCfg.Username)
				assert.Equal(t, "docker-token", authCfg.Password)
				assert.Equal(t, "https://index.docker.io/v1/", authCfg.ServerAddress)

				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "registry-1.docker.io/library/nginx:latest", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, calls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.Equal(t, "docker-user", result.AuthUsername)
	assert.True(t, result.UsedCredential)
}

func TestContainerRegistryService_InspectImageDigest_UsesStoredDockerHubCredentialsForRegistryImage(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
	wantDigest := digest.FromString("stored-credentials-rate-limit").String()

	var calls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				calls++
				assert.Equal(t, "docker.io/library/registry:3", imageRef)

				authCfg := decodeRegistryAuth(t, options.EncodedRegistryAuth)
				assert.Equal(t, "docker-user", authCfg.Username)
				assert.Equal(t, "docker-token", authCfg.Password)
				assert.Equal(t, "https://index.docker.io/v1/", authCfg.ServerAddress)

				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "docker.io/library/registry:3", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, calls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.Equal(t, "docker-user", result.AuthUsername)
	assert.True(t, result.UsedCredential)
}

func TestContainerRegistryService_InspectImageDigest_UsesStoredCredentialsForNonDockerHubRegistry(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "ghcr.io", "ghcr-user", "ghcr-token")
	wantDigest := digest.FromString("ghcr-stored-credentials").String()

	var calls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				calls++
				assert.Equal(t, "ghcr.io/getarcaneapp/agent:latest", imageRef)

				authCfg := decodeRegistryAuth(t, options.EncodedRegistryAuth)
				assert.Equal(t, "ghcr-user", authCfg.Username)
				assert.Equal(t, "ghcr-token", authCfg.Password)

				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "ghcr.io/getarcaneapp/agent:latest", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, calls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.Equal(t, "ghcr-user", result.AuthUsername)
	assert.True(t, result.UsedCredential)
}

// A rate limited anonymous request is not an unauthorized one, so before this was
// fixed a stored ghcr.io credential was never reached. See issue #2635.
func TestContainerRegistryService_InspectImageDigest_UsesStoredCredentialsInsteadOfRateLimitedAnonymous(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "ghcr.io", "ghcr-user", "ghcr-token")
	wantDigest := digest.FromString("ghcr-rate-limit").String()

	var anonymousCalls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				if options.EncodedRegistryAuth == "" {
					anonymousCalls++
					return client.DistributionInspectResult{}, errors.New(
						"Error response from daemon: toomanyrequests: retry-after: 1.246809ms, allowed: 44000/minute",
					)
				}

				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "ghcr.io/getarcaneapp/agent:latest", nil)
	require.NoError(t, err)
	assert.Zero(t, anonymousCalls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.True(t, result.UsedCredential)
}

func TestContainerRegistryService_InspectImageDigest_FallsBackToAnonymousWhenStoredCredentialRejected(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "ghcr.io", "ghcr-user", "expired-token")
	wantDigest := digest.FromString("ghcr-anonymous-fallback").String()

	var anonymousCalls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				if options.EncodedRegistryAuth != "" {
					return client.DistributionInspectResult{}, errors.New("Error response from daemon: unauthorized: authentication required")
				}

				anonymousCalls++
				return client.DistributionInspectResult{
					Descriptor: ocispec.Descriptor{
						Digest: digest.Digest(wantDigest),
					},
				}, nil
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "ghcr.io/immich-app/immich-server:release", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, anonymousCalls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.False(t, result.UsedCredential)
}

// A rate-limited credential must not fall back to anonymous: both paths share the per-registry quota.
func TestContainerRegistryService_InspectImageDigest_DoesNotFallBackToAnonymousOnCredentialRateLimit(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "ghcr.io", "ghcr-user", "ghcr-token")

	var anonymousCalls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				if options.EncodedRegistryAuth == "" {
					anonymousCalls++
				}
				return client.DistributionInspectResult{}, errors.New(
					"Error response from daemon: toomanyrequests: retry-after: 1.246809ms, allowed: 44000/minute",
				)
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "ghcr.io/getarcaneapp/agent:latest", nil)
	require.Error(t, err)
	assert.Zero(t, anonymousCalls, "must not burn anonymous quota when the credential itself is rate limited")
	require.NotNil(t, result)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.True(t, result.UsedCredential)
}

// The direct-HTTP fallback must not spend an anonymous request when a stored credential resolves the digest.
func TestContainerRegistryService_InspectImageDigest_FallbackUsesStoredCredentialsBeforeAnonymous(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	createTestPullRegistry(t, db, "ghcr.io", "ghcr-user", "ghcr-token")
	wantDigest := digest.FromString("fallback-stored-credentials").String()

	var anonymousCalls int
	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				return client.DistributionInspectResult{}, errors.New("Error response from daemon: Not Found")
			},
		}, nil
	}, nil, nil, &http.Client{
		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
			// The version check never carries credentials; only manifest requests count.
			if req.URL.Path == "/v2/" {
				return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: http.NoBody}, nil
			}
			authorization := req.Header.Get("Authorization")
			if authorization == "" {
				anonymousCalls++
				return nil, errors.New("unexpected anonymous registry request")
			}
			assert.Equal(t, "Basic "+base64.StdEncoding.EncodeToString([]byte("ghcr-user:ghcr-token")), authorization)
			return &http.Response{
				StatusCode: http.StatusOK,
				Header: http.Header{
					"Docker-Content-Digest": []string{wantDigest},
					"Content-Type":          []string{"application/vnd.docker.distribution.manifest.v2+json"},
				},
				Body: http.NoBody,
			}, nil
		}),
	})

	result, err := svc.InspectImageDigest(t.Context(), "ghcr.io/getarcaneapp/agent:latest", nil)
	require.NoError(t, err)
	assert.Zero(t, anonymousCalls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "credential", result.AuthMethod)
	assert.Equal(t, "ghcr-user", result.AuthUsername)
	assert.True(t, result.UsedCredential)
}

func TestContainerRegistryService_InspectImageDigest_FallsBackWhenDistributionNotFound(t *testing.T) {
	wantDigest := digest.FromString("fallback-not-found").String()

	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if registryPing(w, r, "") {
			return
		}
		if r.URL.Path == "/v2/team/app/manifests/1.2.3" {
			writeManifestHead(w, wantDigest)
			return
		}
		http.NotFound(w, r)
	}))
	defer server.Close()

	serverURL, err := url.Parse(server.URL)
	require.NoError(t, err)

	var calls int
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				calls++
				assert.Equal(t, serverURL.Host+"/team/app:1.2.3", imageRef)
				assert.Empty(t, options.EncodedRegistryAuth)
				return client.DistributionInspectResult{}, errors.New("Error response from daemon: Not Found")
			},
		}, nil
	}, nil, nil, server.Client())

	result, err := svc.InspectImageDigest(t.Context(), serverURL.Host+"/team/app:1.2.3", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, calls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.Equal(t, serverURL.Host, result.AuthRegistry)
}

func TestContainerRegistryService_InspectImageDigest_FallsBackWhenDistributionForbidden(t *testing.T) {
	wantDigest := digest.FromString("fallback-forbidden").String()

	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if registryPing(w, r, "") {
			return
		}
		if r.URL.Path == "/v2/team/app/manifests/1.2.3" {
			writeManifestHead(w, wantDigest)
			return
		}
		http.NotFound(w, r)
	}))
	defer server.Close()

	serverURL, err := url.Parse(server.URL)
	require.NoError(t, err)

	var calls int
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				calls++
				assert.Equal(t, serverURL.Host+"/team/app:1.2.3", imageRef)
				assert.Empty(t, options.EncodedRegistryAuth)
				return client.DistributionInspectResult{}, errors.New("Error response from daemon: <html><body><h1>403 Forbidden</h1> Request forbidden by administrative r" +
					"ules. </body></html>")
			},
		}, nil
	}, nil, nil, server.Client())

	result, err := svc.InspectImageDigest(t.Context(), serverURL.Host+"/team/app:1.2.3", nil)
	require.NoError(t, err)
	assert.Equal(t, 1, calls)
	assert.Equal(t, wantDigest, result.Digest)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.Equal(t, serverURL.Host, result.AuthRegistry)
}

func TestContainerRegistryService_InspectImageDigest_RetriesStoredCredentialsAfterRegistryAuth403(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	wantDigest := digest.FromString("stored-credential-fallback").String()

	var authHeaders []string
	var tokenURL string
	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		challenge := `Bearer realm="` + tokenURL + `",service="registry.example.com"`
		if registryPing(w, r, challenge) {
			return
		}
		switch r.URL.Path {
		case "/v2/team/app/manifests/1.2.3":
			authHeaders = append(authHeaders, r.Header.Get("Authorization"))
			switch r.Header.Get("Authorization") {
			case "Bearer credential-token":
				w.WriteHeader(http.StatusForbidden)
			case "Bearer anonymous-token":
				writeManifestHead(w, wantDigest)
			default:
				w.Header().Set("WWW-Authenticate", challenge)
				w.WriteHeader(http.StatusUnauthorized)
			}
		case "/token":
			username, password, ok := r.BasicAuth()
			if !ok {
				if !assert.Empty(t, r.Header.Get("Authorization")) {
					return
				}
				if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]string{
					"token": "anonymous-token",
				})) {
					return
				}
				return
			}
			if !assert.Equal(t, "stored-user", username) {
				return
			}
			if !assert.Equal(t, "stored-token", password) {
				return
			}
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]string{
				"token": "credential-token",
			})) {
				return
			}
		default:
			http.NotFound(w, r)
		}
	})
	server := httptest.NewTLSServer(handler)
	defer server.Close()
	tokenURL = server.URL + "/token"

	serverURL, err := url.Parse(server.URL)
	require.NoError(t, err)
	createTestPullRegistry(t, db, server.URL, "stored-user", "stored-token")

	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				return client.DistributionInspectResult{}, errors.New("Error response from daemon: Not Found")
			},
		}, nil
	}, nil, nil, server.Client())

	result, err := svc.InspectImageDigest(t.Context(), serverURL.Host+"/team/app:1.2.3", nil)
	require.NoError(t, err)
	assert.Equal(t, wantDigest, result.Digest)
	// Stored credentials go first; only after rejection does the lookup retry anonymously.
	assert.Equal(t, []string{"Bearer credential-token", "Bearer anonymous-token"}, authHeaders)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.False(t, result.UsedCredential)
}

func TestContainerRegistryService_InspectImageDigest_DoesNotFallbackOnTLSFailure(t *testing.T) {
	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				assert.Equal(t, "registry.example.com/team/app:1.2.3", imageRef)
				assert.Empty(t, options.EncodedRegistryAuth)
				return client.DistributionInspectResult{}, errors.New("tls: failed to verify certificate: x509: certificate signed by unknown authority")
			},
		}, nil
	}, nil, nil)

	result, err := svc.InspectImageDigest(t.Context(), "registry.example.com/team/app:1.2.3", nil)
	require.Error(t, err)
	require.NotNil(t, result)
	assert.Contains(t, strings.ToLower(err.Error()), "x509")
	assert.NotContains(t, err.Error(), "registry fallback failed")
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.Equal(t, "registry.example.com", result.AuthRegistry)
}

func TestContainerRegistryService_InspectImageDigest_PreservesDaemonAndFallbackErrors(t *testing.T) {
	daemonErr := errors.New("Error response from daemon: Not Found")
	fallbackErr := errors.New("dial tcp: i/o timeout")

	svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				return client.DistributionInspectResult{}, daemonErr
			},
		}, nil
	}, nil, nil, &http.Client{
		Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
			return nil, fallbackErr
		}),
	})

	result, err := svc.InspectImageDigest(t.Context(), "registry.example.com/team/app:1.2.3", nil)
	require.Error(t, err)
	require.NotNil(t, result)
	require.ErrorIs(t, err, daemonErr)
	assert.ErrorIs(t, err, fallbackErr)
}

func TestContainerRegistryService_InspectImageDigest_PreservesAnonymousUnauthorizedWhenCredentialLookupFails(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	sqlDB, err := db.DB.DB()
	require.NoError(t, err)
	require.NoError(t, sqlDB.Close())

	var tokenURL string
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		challenge := `Bearer realm="` + tokenURL + `",service="registry.example.com"`
		if registryPing(w, r, challenge) {
			return
		}
		switch r.URL.Path {
		case "/v2/team/app/manifests/1.2.3":
			w.Header().Set("WWW-Authenticate", challenge)
			w.WriteHeader(http.StatusUnauthorized)
		case "/token":
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]string{
				"token": "anonymous-token",
			})) {
				return
			}
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()
	tokenURL = server.URL + "/token"

	serverURL, err := url.Parse(server.URL)
	require.NoError(t, err)

	svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
		return &fakeRegistryDaemonClient{
			distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
				return client.DistributionInspectResult{}, errors.New("Error response from daemon: Not Found")
			},
		}, nil
	}, nil, nil, server.Client())

	result, err := svc.InspectImageDigest(t.Context(), serverURL.Host+"/team/app:1.2.3", nil)
	require.Error(t, err)
	require.NotNil(t, result)
	assert.Equal(t, "anonymous", result.AuthMethod)
	assert.Contains(t, err.Error(), "anonymous access unauthorized")
	assert.Contains(t, err.Error(), "401 Unauthorized")
	assert.Contains(t, err.Error(), "failed to load enabled registries")
}

func createRegistryWithRepositoryNames(t *testing.T, svc *ContainerRegistryService, repositoryNames ...string) *ContainerRegistry {
	t.Helper()

	registryRecord, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:             "https://registry.example.com",
		Username:        "my-user",
		Token:           "my-token",
		RepositoryNames: repositoryNames,
	})
	require.NoError(t, err)

	return registryRecord
}

func fetchRegistry(t *testing.T, db *database.DB, id string) ContainerRegistry {
	t.Helper()

	var fetched ContainerRegistry
	require.NoError(t, db.WithContext(t.Context()).First(&fetched, "id = ?", id).Error)

	return fetched
}

func TestContainerRegistryService_CreateRegistry_NormalizesAndPersistsRepositoryNames(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	// Entries are trimmed, empties dropped and duplicates removed while
	// preserving first-occurrence order.
	registryRecord := createRegistryWithRepositoryNames(t, svc, " team ", "", "team", "team/platform", " team ")
	assert.Equal(t, database.StringSlice{"team", "team/platform"}, registryRecord.RepositoryNames)
	assert.Equal(t, database.StringSlice{"team", "team/platform"}, fetchRegistry(t, db, registryRecord.ID).RepositoryNames)
}

func TestContainerRegistryService_CreateRegistry_RejectsInvalidRepositoryName(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	_, err := svc.CreateRegistry(t.Context(), containerregistry.CreateContainerRegistryRequest{
		URL:             "https://registry.example.com",
		RepositoryNames: []string{"team:latest"},
	})
	require.ErrorIs(t, err, common.ErrValidation)
	fieldErr, ok := errors.AsType[*base.FieldError](err)
	require.True(t, ok)
	assert.Equal(t, "repositoryNames", fieldErr.Field)
}

func TestContainerRegistryService_UpdateRegistry_RepositoryNamesPointerSemantics(t *testing.T) {
	db := setupContainerRegistryTestDB(t)
	svc := NewContainerRegistryService(db, nil, nil, nil)

	registryRecord := createRegistryWithRepositoryNames(t, svc, "team", "team/platform")

	// A nil pointer leaves the existing names untouched.
	updated, err := svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		Username: new("updated-user"),
	})
	require.NoError(t, err)
	assert.Equal(t, database.StringSlice{"team", "team/platform"}, updated.RepositoryNames)

	// An empty slice clears them.
	updated, err = svc.UpdateRegistry(t.Context(), registryRecord.ID, containerregistry.UpdateContainerRegistryRequest{
		RepositoryNames: &[]string{},
	})
	require.NoError(t, err)
	assert.Empty(t, updated.RepositoryNames)
	assert.Empty(t, fetchRegistry(t, db, registryRecord.ID).RepositoryNames)
}

func TestListImageTagsCredentials(t *testing.T) {
	for _, tt := range []struct {
		name         string
		external     []containerregistry.Credential
		wantUser     string
		wantPassword string
	}{
		{name: "stored", wantUser: "stored-user", wantPassword: "stored-token"},
		{
			name: "external overrides stored",
			external: []containerregistry.Credential{{
				URL:      "docker.io",
				Username: "external-user",
				Token:    "external-token",
				Enabled:  true,
			}},
			wantUser:     "external-user",
			wantPassword: "external-token",
		},
		{name: "external excludes unrelated stored", external: []containerregistry.Credential{{URL: "other.test", Username: "external-user", Token: "external-token", Enabled: true}}},
		{name: "disabled external ignored", external: []containerregistry.Credential{{URL: "docker.io", Username: "external-user", Token: "external-token", Enabled: false}}},
	} {
		t.Run(tt.name, func(t *testing.T) {
			db := setupContainerRegistryTestDB(t)
			createTestPullRegistry(t, db, "https://index.docker.io/v1/", "stored-user", "stored-token")
			calls := 0
			httpClient := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
				assert.Equal(t, "registry-1.docker.io", req.URL.Host)
				if req.URL.Path == "/v2/" {
					return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, Header: http.Header{}}, nil
				}
				calls++
				assert.Equal(t, "/v2/library/nginx/tags/list", req.URL.Path)
				user, password, _ := req.BasicAuth()
				assert.Equal(t, tt.wantUser, user)
				assert.Equal(t, tt.wantPassword, password)
				return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(`{"name":"library/nginx","tags":["1.2.3","1.2.4"]}`)), Header: http.Header{}}, nil
			})}
			svc := NewContainerRegistryService(db, nil, nil, nil, httpClient)
			tags, err := svc.ListImageTags(t.Context(), "nginx:1.2.3", tt.external)
			require.NoError(t, err)
			assert.Equal(t, []string{"1.2.3", "1.2.4"}, tags)
			assert.Equal(t, 1, calls)
		})
	}
}

func TestListImageTagsDoesNotFallBackOnRateLimit(t *testing.T) {
	// The registry client retries 429s itself, so count credentialed and anonymous listings rather than requests.
	credentialed, anonymous := 0, 0
	svc := NewContainerRegistryService(nil, nil, nil, nil, &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
		if req.URL.Path == "/v2/" {
			return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, Header: http.Header{}}, nil
		}
		if req.Header.Get("Authorization") == "" {
			anonymous++
		} else {
			credentialed++
		}
		return &http.Response{StatusCode: http.StatusTooManyRequests, Body: http.NoBody, Header: http.Header{}}, nil
	})})
	tags, err := svc.ListImageTags(
		t.Context(),
		"registry.test/team/app:1.0.0",
		[]containerregistry.Credential{{
			URL:      "registry.test",
			Username: "user",
			Token:    "token",
			Enabled:  true,
		}},
	)
	require.Error(t, err)
	assert.Nil(t, tags)
	assert.Positive(t, credentialed)
	assert.Zero(t, anonymous, "a rate-limited credential must not spend the anonymous quota")
}

func TestListImageTagsCancellation(t *testing.T) {
	svc := NewContainerRegistryService(nil, nil, nil, nil)
	ctx, cancel := context.WithCancel(t.Context())
	cancel()
	_, err := svc.ListImageTags(ctx, "registry.test/team/app:1.0.0", nil)
	require.ErrorIs(t, err, context.Canceled, "error = %v", err)
}

func TestListImageTagsRejectedCredentialFallback(t *testing.T) {
	basic := "Basic " + base64.StdEncoding.EncodeToString([]byte("user:token"))
	for _, tt := range []struct {
		name          string
		host          string
		wantError     bool
		wantTokenAuth []string
	}{
		{name: "private registry public image", host: "registry.test", wantTokenAuth: []string{basic, ""}},
		{name: "docker hub preserves quota", host: "docker.io", wantError: true, wantTokenAuth: []string{basic}},
	} {
		t.Run(tt.name, func(t *testing.T) {
			// The registry challenges at /v2/ and its token endpoint rejects the stored credential but serves anonymous tokens.
			var tokenAuth []string
			svc := NewContainerRegistryService(nil, nil, nil, nil, &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
				switch req.URL.Path {
				case "/v2/":
					return &http.Response{
						StatusCode: http.StatusUnauthorized,
						Header:     http.Header{"Www-Authenticate": []string{`Bearer realm="https://auth.test/token"`}},
						Body:       http.NoBody,
					}, nil
				case "/token":
					tokenAuth = append(tokenAuth, req.Header.Get("Authorization"))
					if req.Header.Get("Authorization") != "" {
						return &http.Response{StatusCode: http.StatusUnauthorized, Header: http.Header{}, Body: http.NoBody}, nil
					}
					return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(`{"token":"anonymous-token"}`))}, nil
				default:
					return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(`{"tags":["1.0.1"]}`))}, nil
				}
			})})
			tags, err := svc.ListImageTags(t.Context(), tt.host+"/team/app:1.0.0", []containerregistry.Credential{{URL: tt.host, Username: "user", Token: "token", Enabled: true}})
			if tt.wantError {
				require.Error(t, err)
				assert.Nil(t, tags)
			} else {
				require.NoError(t, err)
				assert.Equal(t, []string{"1.0.1"}, tags)
			}
			assert.Equal(t, tt.wantTokenAuth, tokenAuth)
		})
	}
}

// newLabelTestRegistry starts an in-memory OCI registry and returns its
// host as "localhost:PORT" so go-containerregistry resolves it over plain HTTP.
func newLabelTestRegistry(t *testing.T) string {
	t.Helper()
	server := httptest.NewServer(registry.New(registry.Logger(log.New(io.Discard, "", 0))))
	t.Cleanup(server.Close)
	serverURL, err := url.Parse(server.URL)
	require.NoError(t, err)
	return "localhost:" + serverURL.Port()
}

func pushLabeledImage(t *testing.T, imageRef string, imageLabels map[string]string) v1.Image {
	t.Helper()
	img, err := random.Image(64, 1)
	require.NoError(t, err)

	if imageLabels != nil {
		img, err = mutate.Config(img, v1.Config{Labels: imageLabels})
		require.NoError(t, err)
	}

	ref, err := name.ParseReference(imageRef)
	require.NoError(t, err)
	require.NoError(t, remote.Write(ref, img))
	return img
}

func TestContainerRegistryService_ImageVersionLabel(t *testing.T) {
	host := newLabelTestRegistry(t)
	imageRef := host + "/getarcaneapp/arcane:next"
	img := pushLabeledImage(t, imageRef, map[string]string{
		ociImageVersionLabel: "v2.8.0-next.66",
	})

	svc := NewContainerRegistryService(nil, nil, nil, nil)

	label, err := svc.ImageVersionLabel(t.Context(), imageRef)
	require.NoError(t, err)
	assert.Equal(t, "v2.8.0-next.66", label)

	// Digest references resolve too — the version service prefers them.
	imgDigest, err := img.Digest()
	require.NoError(t, err)
	label, err = svc.ImageVersionLabel(t.Context(), host+"/getarcaneapp/arcane@"+imgDigest.String())
	require.NoError(t, err)
	assert.Equal(t, "v2.8.0-next.66", label)
}

func TestContainerRegistryService_ImageVersionLabelMissingLabel(t *testing.T) {
	host := newLabelTestRegistry(t)
	imageRef := host + "/getarcaneapp/arcane:next"
	pushLabeledImage(t, imageRef, nil)

	svc := NewContainerRegistryService(nil, nil, nil, nil)
	_, err := svc.ImageVersionLabel(t.Context(), imageRef)
	assert.ErrorIs(t, err, ErrNoVersionLabel)
}

func TestContainerRegistryService_ImageVersionLabelErrorNotCached(t *testing.T) {
	host := newLabelTestRegistry(t)
	imageRef := host + "/getarcaneapp/arcane:next"

	svc := NewContainerRegistryService(nil, nil, nil, nil)

	// The image does not exist yet: the lookup must fail...
	_, err := svc.ImageVersionLabel(t.Context(), imageRef)
	require.Error(t, err)

	// ...and the failure must not be cached: after the push the same ref resolves.
	pushLabeledImage(t, imageRef, map[string]string{
		ociImageVersionLabel: "v2.8.0-next.67",
	})
	label, err := svc.ImageVersionLabel(t.Context(), imageRef)
	require.NoError(t, err)
	assert.Equal(t, "v2.8.0-next.67", label)
}

func TestClassifyDigestError(t *testing.T) {
	cases := map[string]struct {
		err  error
		kind error
	}{
		"rate limit":         {errors.New("toomanyrequests: rate limit exceeded"), common.ErrUnavailable},
		"server error":       {&transport.Error{StatusCode: http.StatusBadGateway}, common.ErrUnavailable},
		"connection refused": {errors.New("dial tcp 10.0.0.1:443: connect: connection refused"), common.ErrUnavailable},
		"unauthorized":       {&transport.Error{StatusCode: http.StatusUnauthorized}, common.ErrUnauthorized},
		"not found":          {&transport.Error{StatusCode: http.StatusNotFound}, common.ErrNotFound},
		"manifest unknown":   {errors.New("MANIFEST_UNKNOWN: manifest unknown"), common.ErrNotFound},
	}
	for name, tc := range cases {
		require.ErrorIs(t, classifyDigestError(tc.err), tc.kind, name)
	}

	plain := errors.New("x509: certificate signed by unknown authority")
	classified := classifyDigestError(plain)
	require.Equal(t, plain, classified)
	require.NotErrorIs(t, classified, common.ErrUnavailable)
	// A host that does not resolve never comes back, so it must not be retried like an outage.
	unknownHost := &url.Error{Op: "Get", URL: "https://invalid-registry.example.com/v2/", Err: &net.DNSError{Err: "no such host", Name: "invalid-registry.example.com", IsNotFound: true}}
	require.NotErrorIs(t, classifyDigestError(unknownHost), common.ErrUnavailable)
}