Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package docker
import (
"context"
"encoding/json"
"net"
"net/http"
"net/http/httptest"
"path"
"sync/atomic"
"testing"
"time"
imagetypes "github.com/getarcaneapp/arcane/types/v2/image"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/events"
"github.com/moby/moby/api/types/image"
"github.com/moby/moby/client"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/concurrency"
)
func TestDockerClientService_GetClientPinsEffectiveAPIVersion(t *testing.T) {
t.Setenv("DOCKER_API_VERSION", "1.54")
t.Setenv("DOCKER_HOST", "tcp://docker-from-env:2375")
tests := []struct {
name string
pingAPIVersion string
expectedVersion string
}{
{
name: "uses server API version",
pingAPIVersion: "1.41",
expectedVersion: "1.41",
},
{
name: "falls back to minimum API version when ping version is empty",
pingAPIVersion: "",
expectedVersion: client.MinAPIVersion,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server := newDockerPingTestServer(t, func() string { return tt.pingAPIVersion })
svc := newDockerClientServiceForTest(t, server.URL)
t.Cleanup(svc.Close)
cli, err := svc.GetClient(t.Context())
require.NoError(t, err)
assert.Equal(t, server.URL, cli.DaemonHost())
assert.Equal(t, tt.expectedVersion, cli.ClientVersion())
assert.NotEqual(t, client.MaxAPIVersion, cli.ClientVersion())
})
}
}
func TestDockerClientService_GetClientReturnsCachedClientUntilRefresh(t *testing.T) {
server := newDockerPingTestServer(t, func() string { return "1.41" })
svc := newDockerClientServiceForTest(t, server.URL)
firstClient, err := svc.GetClient(t.Context())
require.NoError(t, err)
t.Cleanup(func() {
_ = firstClient.Close()
})
secondClient, err := svc.GetClient(t.Context())
require.NoError(t, err)
assert.Same(t, firstClient, secondClient)
assert.Equal(t, "1.41", secondClient.ClientVersion())
}
func TestDockerClientService_RefreshClientRecreatesCachedClientAfterAPIVersionChange(t *testing.T) {
apiVersion := atomic.Value{}
apiVersion.Store("1.41")
server := newDockerPingTestServer(t, func() string {
return apiVersion.Load().(string)
})
svc := newDockerClientServiceForTest(t, server.URL)
firstClient, err := svc.GetClient(t.Context())
require.NoError(t, err)
t.Cleanup(func() {
_ = firstClient.Close()
})
assert.Equal(t, "1.41", firstClient.ClientVersion())
apiVersion.Store("1.42")
err = svc.RefreshClient(t.Context())
require.NoError(t, err)
secondClient := svc.Client
t.Cleanup(func() {
_ = secondClient.Close()
})
assert.NotSame(t, firstClient, secondClient)
assert.Equal(t, "1.42", secondClient.ClientVersion())
}
func TestDockerClientService_RefreshClientClosesOldCachedClientWhenReplaced(t *testing.T) {
var oldServerClosedConnections atomic.Int32
oldServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/_ping" {
http.NotFound(w, r)
return
}
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
}))
oldServer.Config.ConnState = func(_ net.Conn, state http.ConnState) {
if state == http.StateClosed {
oldServerClosedConnections.Add(1)
}
}
oldServer.Start()
t.Cleanup(oldServer.Close)
newServer := newDockerPingTestServer(t, func() string { return "1.42" })
svc := newDockerClientServiceForTest(t, oldServer.URL)
firstClient, err := svc.GetClient(t.Context())
require.NoError(t, err)
t.Cleanup(func() {
_ = firstClient.Close()
})
_, err = firstClient.Ping(t.Context(), client.PingOptions{})
require.NoError(t, err)
closedBeforeReplace := oldServerClosedConnections.Load()
svc.config.DockerHost = newServer.URL
err = svc.RefreshClient(t.Context())
require.NoError(t, err)
secondClient := svc.Client
t.Cleanup(func() {
_ = secondClient.Close()
})
require.Eventually(t, func() bool {
return oldServerClosedConnections.Load() > closedBeforeReplace
}, time.Second, 10*time.Millisecond)
assert.NotSame(t, firstClient, secondClient)
assert.Equal(t, "1.42", secondClient.ClientVersion())
}
func TestDockerClientService_RefreshClientProbeFailureKeepsCachedClient(t *testing.T) {
var failProbe atomic.Bool
server := newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/_ping" {
http.NotFound(w, r)
return
}
if failProbe.Load() {
w.WriteHeader(http.StatusForbidden)
return
}
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
})
svc := newDockerClientServiceForTest(t, server.URL)
firstClient, err := svc.GetClient(t.Context())
require.NoError(t, err)
t.Cleanup(func() {
_ = firstClient.Close()
})
failProbe.Store(true)
err = svc.RefreshClient(t.Context())
require.Error(t, err)
assert.Same(t, firstClient, svc.Client)
assert.Equal(t, "1.41", svc.clientVersion)
assert.False(t, svc.clientLastProbe.IsZero())
}
func TestDockerClientService_PublishesDaemonImageEvents(t *testing.T) {
expected := events.Message{Type: events.ImageEventType, Action: events.ActionPull, TimeNano: 123, Actor: events.Actor{ID: "nginx:latest"}}
payload, err := json.Marshal(expected)
require.NoError(t, err)
server := newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
switch path.Base(r.URL.Path) {
case "_ping":
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
case "events":
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(payload)
default:
http.NotFound(w, r)
}
})
svc := newDockerClientServiceForTest(t, server.URL)
t.Cleanup(svc.Close)
eventCh, unsubscribe := svc.EventBus().Subscribe(events.ImageEventType)
t.Cleanup(unsubscribe)
stop, err := concurrency.StartSupervised(t.Context(), "Docker event watcher", func(ctx context.Context) error {
svc.WatchEvents(ctx)
return nil
})
require.NoError(t, err)
t.Cleanup(func() { _ = stop(context.WithoutCancel(t.Context())) })
select {
case message := <-eventCh:
require.Equal(t, expected, message)
case <-time.After(time.Second):
t.Fatal("daemon image event was not published")
}
}
func TestDockerClientService_EventActorStopCancelsAndJoinsStream(t *testing.T) {
streamStarted := make(chan struct{})
streamStopped := make(chan struct{})
server := newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
switch path.Base(r.URL.Path) {
case "_ping":
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
case "events":
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
if flusher, ok := w.(http.Flusher); ok {
flusher.Flush()
}
close(streamStarted)
<-r.Context().Done()
close(streamStopped)
default:
http.NotFound(w, r)
}
})
service := newDockerClientServiceForTest(t, server.URL)
t.Cleanup(service.Close)
eventsCh, unsubscribe := service.EventBus().Subscribe(events.ImageEventType)
t.Cleanup(unsubscribe)
stop, err := concurrency.StartSupervised(t.Context(), "Docker event watcher", func(ctx context.Context) error {
service.WatchEvents(ctx)
return nil
})
require.NoError(t, err)
select {
case <-streamStarted:
case <-time.After(time.Second):
require.FailNow(t, "Docker event stream did not start")
}
select {
case message := <-eventsCh:
t.Fatalf("connecting without daemon events published an unexpected event: %v", message)
default:
}
stopCtx, cancel := context.WithTimeout(t.Context(), time.Second)
defer cancel()
require.NoError(t, stop(stopCtx))
require.Eventually(t, func() bool {
select {
case <-streamStopped:
return true
default:
return false
}
}, time.Second, time.Millisecond)
}
func TestDockerClientService_WatchEventsResumesFromLastEventAfterRefresh(t *testing.T) {
first := events.Message{
Type: events.ImageEventType,
Action: events.ActionPull,
TimeNano: 1_700_000_000_123_456_789,
}
payload, err := json.Marshal(first)
require.NoError(t, err)
var pings, eventCalls atomic.Int32
type reconnect struct {
since string
pings int32
}
reconnected := make(chan reconnect, 1)
server := newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
switch path.Base(r.URL.Path) {
case "_ping":
pings.Add(1)
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
case "events":
w.Header().Set("Content-Type", "application/json")
if eventCalls.Add(1) == 1 {
assert.Empty(t, r.URL.Query().Get("since"))
_, _ = w.Write(payload)
return
}
select {
case reconnected <- reconnect{since: r.URL.Query().Get("since"), pings: pings.Load()}:
default:
}
w.WriteHeader(http.StatusOK)
<-r.Context().Done()
default:
http.NotFound(w, r)
}
})
svc := newDockerClientServiceForTest(t, server.URL)
t.Cleanup(svc.Close)
stop, err := concurrency.StartSupervised(t.Context(), "Docker event watcher", func(ctx context.Context) error {
svc.WatchEvents(ctx)
return nil
})
require.NoError(t, err)
t.Cleanup(func() { _ = stop(context.WithoutCancel(t.Context())) })
select {
case got := <-reconnected:
assert.Equal(t, "1700000000.123456790", got.since)
// One probe from the initial GetClient, one from the RefreshClient before reconnecting.
assert.GreaterOrEqual(t, got.pings, int32(2))
case <-time.After(5 * time.Second):
t.Fatal("event stream did not reconnect")
}
}
func TestDockerClientService_EngineCachesUntilClientChanges(t *testing.T) {
var versionCalls atomic.Int32
server := newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
switch path.Base(r.URL.Path) {
case "_ping":
w.Header().Set("Api-Version", "1.41")
w.WriteHeader(http.StatusOK)
case "version":
versionCalls.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"Platform":{"Name":"Podman Engine"}}`))
case "info":
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"CgroupVersion":"2"}`))
default:
http.NotFound(w, r)
}
})
svc := newDockerClientServiceForTest(t, server.URL)
t.Cleanup(svc.Close)
first, err := svc.Engine(t.Context())
require.NoError(t, err)
second, err := svc.Engine(t.Context())
require.NoError(t, err)
assert.Equal(t, "podman", first.Name)
assert.Equal(t, "2", first.CgroupVersion)
assert.Equal(t, first, second)
assert.Equal(t, int32(1), versionCalls.Load())
copied := svc.WithClient(svc.Client)
_, err = copied.Engine(t.Context())
require.NoError(t, err)
assert.Equal(t, int32(2), versionCalls.Load())
svc.Close()
_, err = svc.Engine(t.Context())
require.NoError(t, err)
assert.Equal(t, int32(3), versionCalls.Load())
}
func TestCountImageUsage_UsesContainerImageIDs(t *testing.T) {
images := []image.Summary{
{ID: "sha256:image-a", Containers: -1, Size: 100},
{ID: "sha256:image-b", Containers: 0, Size: 25},
{ID: "sha256:image-c", Containers: 99, Size: 3},
}
containers := []container.Summary{
{ImageID: "sha256:image-a"},
{ImageID: "sha256:image-c"},
{ImageID: "sha256:image-a"}, // duplicate container ref should not affect counts
{ImageID: ""},
}
counts := CountImageUsage(images, containers)
assert.Equal(t, 2, counts.Inuse)
assert.Equal(t, 1, counts.Unused)
assert.Equal(t, 3, counts.Total)
assert.Equal(t, int64(128), counts.TotalSize)
}
func TestCountImageUsage_NoImages(t *testing.T) {
counts := CountImageUsage(nil, []container.Summary{{ImageID: "sha256:image-a"}})
assert.Equal(t, imagetypes.UsageCounts{}, counts)
}
func newDockerClientServiceForTest(t *testing.T, host string) *DockerClientService {
return NewDockerClientService(t.Context(), nil, &config.Config{DockerHost: host}, nil)
}
func newDockerPingTestServer(t *testing.T, apiVersion func() string) *httptest.Server {
t.Helper()
return newDockerPingTestServerWithHandler(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/_ping" {
http.NotFound(w, r)
return
}
if version := apiVersion(); version != "" {
w.Header().Set("Api-Version", version)
}
w.WriteHeader(http.StatusOK)
})
}
func newDockerPingTestServerWithHandler(t *testing.T, handler http.HandlerFunc) *httptest.Server {
t.Helper()
server := httptest.NewServer(handler)
t.Cleanup(server.Close)
return server
}