Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package patch
import (
"context"
"encoding/json/v2"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/getarcaneapp/arcane/types/v2/base"
"github.com/getarcaneapp/arcane/types/v2/features"
"github.com/getarcaneapp/arcane/types/v2/imagepatch"
"github.com/getarcaneapp/arcane/types/v2/user"
"github.com/libtnb/sqlite"
"github.com/moby/moby/client"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.getarcane.app/kit/pkg"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
)
func TestResolvePatchedRef(t *testing.T) {
tests := []struct {
name string
imageRef string
patchedTag string
suffix string
want string
}{
{
name: "default suffix",
imageRef: "nginx:1.25",
suffix: "patched",
want: "docker.io/library/nginx:1.25-patched",
},
{
name: "explicit tag override with registry port",
imageRef: "registry.local:5000/app:2.0",
patchedTag: "2.0-hardened",
suffix: "patched",
want: "registry.local:5000/app:2.0-hardened",
},
{
name: "custom suffix",
imageRef: "ghcr.io/acme/api:v3",
suffix: "fixed",
want: "ghcr.io/acme/api:v3-fixed",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := resolvePatchedRef(tt.imageRef, tt.patchedTag, tt.suffix)
require.NoError(t, err)
require.Equal(t, tt.want, got)
})
}
}
func TestListPatchTargets_ExcludesUntaggedImages(t *testing.T) {
ctx := t.Context()
dsn := fmt.Sprintf("file:image-patch-test-%d?mode=memory&cache=shared", time.Now().UnixNano())
gdb, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&vulnerability.VulnerabilityScanRecord{}, &vulnerability.VulnerabilityReportRecord{}, &ImagePatchRecord{}))
db := &database.DB{DB: gdb}
svc := NewService(db, docker.NewDockerClientService(ctx, nil, &config.Config{DockerHost: "unix:///nonexistent-arcane-test.sock"}, nil), nil, nil, nil, nil)
records := []vulnerability.VulnerabilityScanRecord{
{
ID: "sha256:aaa",
ImageName: "nginx:latest",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
FixableCount: new(3),
},
{
ID: "sha256:bbb",
ImageName: "sha256:bbb",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
FixableCount: new(3),
},
{
ID: "sha256:ccc",
ImageName: "<none>:<none>",
Status: vulnerability.ScanStatusCompleted,
ScanTime: time.Now(),
FixableCount: new(3),
},
}
for i := range records {
require.NoError(t, db.Create(&records[i]).Error)
require.NoError(t, db.Create(&vulnerability.VulnerabilityReportRecord{ImageID: records[i].ID, Data: "{}"}).Error)
}
targets, _, err := svc.ListPatchTargets(ctx, "0", pagination.QueryParams{Limit: 20})
require.NoError(t, err)
require.Len(t, targets, 1)
require.Equal(t, "nginx:latest", targets[0].ImageRef)
}
func patchFeatureSettings(t *testing.T) (*settings.SettingsService, *database.DB) {
t.Helper()
gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &vulnerability.VulnerabilityScanRecord{}, &vulnerability.VulnerabilityReportRecord{}, &ImagePatchRecord{}))
db := &database.DB{DB: gdb}
svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
require.NoError(t, err)
return svc, db
}
func TestVulnerabilityFeatureBlocksReportPatchesOnly(t *testing.T) {
settingsSvc, db := patchFeatureSettings(t)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
svc := NewService(
db,
docker.NewDockerClientService(t.Context(), nil, &config.Config{DockerHost: "unix:///nonexistent-arcane-feature-test.sock"}, nil),
settingsSvc,
nil,
nil,
nil,
)
_, err := svc.PatchImage(t.Context(), "0", "test-image", imagepatch.PatchOptions{ScanID: "test-image"}, user.Actor{})
require.ErrorIs(t, err, common.ErrFeatureDisabled)
_, _, err = svc.ListPatchTargets(t.Context(), "0", pagination.QueryParams{})
require.ErrorIs(t, err, common.ErrFeatureDisabled)
_, err = svc.Targets(t.Context(), "0")
require.ErrorIs(t, err, common.ErrFeatureDisabled)
// Standalone patching still reaches Docker; this test deliberately has no daemon.
_, err = svc.PatchImage(t.Context(), "0", "test-image", imagepatch.PatchOptions{}, user.Actor{})
require.Error(t, err)
require.NotErrorIs(t, err, common.ErrFeatureDisabled)
require.Contains(t, err.Error(), "failed to connect to Docker")
}
func TestQueuedReportPatchStopsWhenFeatureDisabled(t *testing.T) {
settingsSvc, db := patchFeatureSettings(t)
svc := NewService(db, nil, settingsSvc, nil, nil, nil)
record := &ImagePatchRecord{
EnvironmentID: "0",
OriginalImageID: "test-image",
Mode: string(imagepatch.PatchModeReport),
Status: string(imagepatch.PatchStatusPatching),
}
require.NoError(t, db.Create(record).Error)
svc.patchSlot <- struct{}{}
done := make(chan struct{})
go func() {
defer close(done)
_ = svc.runPatch(t.Context(), record, imagepatch.PatchOptions{ScanID: "test-image"}, nil, "", "")
}()
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
// The active patch owns its slot until it finishes normally.
require.Len(t, svc.patchSlot, 1)
<-svc.patchSlot
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("queued patch did not stop")
}
var stored ImagePatchRecord
require.NoError(t, db.First(&stored, "id = ?", record.ID).Error)
require.Equal(t, string(imagepatch.PatchStatusFailed), stored.Status)
require.NotNil(t, stored.Error)
require.Contains(t, *stored.Error, string(features.VulnerabilityManagement))
require.Empty(t, svc.patchSlot)
}
func TestDisabledFeatureSkipsPatchVerificationScan(t *testing.T) {
settingsSvc, _ := patchFeatureSettings(t)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
var inspected atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
inspected.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"Id":"patched-image"}`))
}))
defer server.Close()
dockerClient, err := client.New(client.WithHost(server.URL), client.WithAPIVersion("1.41"))
require.NoError(t, err)
defer func() { assert.NoError(t, dockerClient.Close()) }()
svc := NewService(
nil,
&docker.DockerClientService{Client: dockerClient},
settingsSvc,
nil,
nil,
// Any attempt to scan would access unconfigured dependencies and fail.
&vulnerability.VulnerabilityService{},
)
require.NotPanics(t, func() {
svc.verifyPatchedImage(t.Context(), &ImagePatchRecord{EnvironmentID: "0", PatchedRef: "test:patched"}, "")
})
require.Equal(t, int32(1), inspected.Load())
}
func TestAggregatePatchTargetsMergesEnvironments(t *testing.T) {
scanned := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
bodies := map[string]base.Paginated[imagepatch.PatchTarget]{
"a": {
Success: true,
Data: []imagepatch.PatchTarget{
{
ImageID: "sha256:a1",
ImageRef: "nginx:1",
FixableCount: 3,
ScanTime: scanned.Add(2 * time.Hour),
},
{
ImageID: "sha256:a2",
ImageRef: "redis:7",
FixableCount: 1,
ScanTime: scanned,
},
},
Pagination: base.PaginationResponse{TotalItems: 2, GrandTotalItems: 4},
},
"b": {
Success: true,
Data: []imagepatch.PatchTarget{
{
ImageID: "sha256:b1",
ImageRef: "alpine:3",
FixableCount: 5,
ScanTime: scanned.Add(time.Hour),
},
},
Pagination: base.PaginationResponse{TotalItems: 1},
},
}
var queries sync.Map
ctx := httpx.WithEnvironmentScope(t.Context(), &httpx.EnvironmentScope{
IDs: []string{"a", "b", "c"},
Request: httptest.NewRequest(http.MethodGet, "/api/environments/a,b,c/images/patch-targets?start=0&limit=20&order=desc", http.NoBody),
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := strings.Split(strings.TrimPrefix(r.URL.Path, "/api/environments/"), "/")[0]
queries.Store(id, r.URL.Query())
body, ok := bodies[id]
if !ok {
w.WriteHeader(http.StatusBadGateway)
_, _ = w.Write([]byte(`{"detail":"environment offline"}`))
return
}
payload, err := json.Marshal(body)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
_, _ = w.Write(payload)
}),
Resolve: func(_ context.Context, id string) (base.EnvironmentRef, error) {
return base.EnvironmentRef{ID: id, Name: "Env " + id}, nil
},
})
rowLabels := func(items []imagepatch.PatchTarget) []string {
out := make([]string, 0, len(items))
for _, item := range items {
out = append(out, item.EnvironmentID+"/"+item.ImageRef)
}
return out
}
svc := NewService(nil, nil, nil, nil, nil, nil)
merge := func(sort string, order pagination.SortOrder, start, limit int) base.Paginated[imagepatch.PatchTarget] {
body, err := svc.AggregatePatchTargets(ctx, pagination.QueryParams{
SortParams: pagination.SortParams{Sort: sort, Order: order},
Params: pagination.Params{Start: start, Limit: limit},
})
require.NoError(t, err)
return body
}
defaults := merge("", pagination.SortDesc, 0, 20)
assert.True(t, defaults.Success)
assert.Equal(t, []string{"a/nginx:1", "b/alpine:3", "a/redis:7"}, rowLabels(defaults.Data))
assert.Equal(t, "Env a", defaults.Data[0].EnvironmentName)
assert.Equal(t, int64(3), defaults.Pagination.TotalItems)
assert.Equal(t, int64(5), defaults.Pagination.GrandTotalItems)
require.Len(t, defaults.FailedEnvironments, 1)
assert.Equal(t, "c", defaults.FailedEnvironments[0].Environment.ID)
for _, id := range []string{"a", "b"} {
query, ok := queries.Load(id)
require.True(t, ok)
assert.Equal(t, "0", query.(url.Values).Get("start"))
assert.Equal(t, "-1", query.(url.Values).Get("limit"))
}
assert.Equal(t, []string{"b/alpine:3", "a/nginx:1", "a/redis:7"}, rowLabels(merge("imageName", pagination.SortAsc, 0, -1).Data))
assert.Equal(t, []string{"b/alpine:3", "a/nginx:1"}, rowLabels(merge("fixableCount", pagination.SortDesc, 0, 2).Data))
assert.Equal(t, []string{"a/redis:7", "a/nginx:1", "b/alpine:3"}, rowLabels(merge("environment", pagination.SortAsc, 0, -1).Data))
}
func TestRecoverInterruptedPatchesFailsLeftoverPatchingRecords(t *testing.T) {
_, db := patchFeatureSettings(t)
svc := &Service{db: db}
for _, record := range []ImagePatchRecord{
{
BaseModel: database.BaseModel{ID: "stuck"},
Status: string(imagepatch.PatchStatusPatching),
},
{
BaseModel: database.BaseModel{ID: "done"},
Status: string(imagepatch.PatchStatusCompleted),
},
} {
require.NoError(t, db.Create(&record).Error)
}
require.NoError(t, svc.RecoverInterruptedPatches(t.Context()))
var stuck, done ImagePatchRecord
require.NoError(t, db.First(&stuck, "id = ?", "stuck").Error)
require.NoError(t, db.First(&done, "id = ?", "done").Error)
assert.Equal(t, string(imagepatch.PatchStatusFailed), stuck.Status)
assert.Equal(t, errPatchInterrupted.Error(), kit.FromPtr(stuck.Error))
assert.Equal(t, string(imagepatch.PatchStatusCompleted), done.Status)
assert.Nil(t, done.Error)
}