Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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)
}