Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package dashboard
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/getarcaneapp/arcane/types/v2/dashboard"
"github.com/getarcaneapp/arcane/types/v2/user"
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
"github.com/libtnb/sqlite"
dockercontainer "github.com/moby/moby/api/types/container"
dockerimage "github.com/moby/moby/api/types/image"
"github.com/moby/moby/api/types/mount"
dockervolume "github.com/moby/moby/api/types/volume"
"github.com/moby/moby/client"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.getarcane.app/docker/compat"
"go.getarcane.app/updater/labels"
"go.opentelemetry.io/otel/sdk/metric"
"go.opentelemetry.io/otel/sdk/metric/metricdata"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/apikey"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/container"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/image"
"github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"
"github.com/getarcaneapp/arcane/backend/v2/internal/podman"
"github.com/getarcaneapp/arcane/backend/v2/internal/project"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/volume"
libpodman "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/podman"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref"
)
var testDockerService = &docker.DockerClientService{Client: func() *client.Client {
cli, _ := client.New(client.WithHost("tcp://127.0.0.1:1"), client.WithAPIVersion("1.41"))
return cli
}()}
func setupDashboardServiceTestDB(t *testing.T) (*database.DB, *settings.SettingsService) {
t.Helper()
db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&apikey.ApiKey{}, &environment.Environment{}, &imageupdate.ImageUpdateRecord{}, &project.Project{}, &settings.SettingVariable{}))
databaseDB := &database.DB{DB: db}
settingsSvc, err := settings.NewSettingsService(t.Context(), databaseDB, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsSvc.Stop(context.WithoutCancel(t.Context()))) })
return databaseDB, settingsSvc
}
func createDashboardTestAPIKey(t *testing.T, db *database.DB, key apikey.ApiKey) {
t.Helper()
require.NoError(t, db.WithContext(t.Context()).Create(&key).Error)
}
func createDashboardTestImageUpdateRecord(t *testing.T, db *database.DB, record imageupdate.ImageUpdateRecord) {
t.Helper()
require.NoError(t, db.WithContext(t.Context()).Create(&record).Error)
}
func newDashboardTestDockerService(
t *testing.T,
settingsSvc *settings.SettingsService,
containers []dockercontainer.Summary,
images []dockerimage.Summary,
volumes []dockervolume.Volume,
) *docker.DockerClientService {
t.Helper()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch {
case strings.HasSuffix(r.URL.Path, "/containers/json"):
if !assert.NoError(t, json.NewEncoder(w).Encode(containers)) {
return
}
case strings.HasSuffix(r.URL.Path, "/images/json"):
if !assert.NoError(t, json.NewEncoder(w).Encode(images)) {
return
}
case strings.HasSuffix(r.URL.Path, "/volumes"):
if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Volumes": volumes, "Warnings": []string{}})) {
return
}
default:
http.NotFound(w, r)
}
}))
t.Cleanup(server.Close)
dockerClient, err := client.New(
client.WithHost(server.URL),
client.WithAPIVersion("1.41"),
)
require.NoError(t, err)
t.Cleanup(func() {
_ = dockerClient.Close()
})
return docker.NewDockerClientService(t.Context(), nil, nil, settingsSvc).WithClient(dockerClient)
}
func TestDashboardService_GetSnapshot_ReturnsDashboardSnapshot(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
containers := []dockercontainer.Summary{
{
ID: "container-running",
Names: []string{"/running-app"},
Image: "repo/app:stable",
ImageID: "sha256:image-a",
Created: 1700000000,
State: "running",
Status: "Up 2 hours",
Labels: map[string]string{},
Mounts: []dockercontainer.MountPoint{
{Type: mount.TypeVolume, Name: "app-data"},
},
},
{
ID: "container-stopped",
Names: []string{"/stopped-app"},
Image: "repo/worker:latest",
ImageID: "sha256:image-b",
Created: 1800000000,
State: "exited",
Status: "Exited (0) 1 hour ago",
Labels: map[string]string{},
},
{
ID: "container-internal",
Names: []string{"/arcane"},
Image: "ghcr.io/getarcaneapp/arcane:latest",
ImageID: "sha256:image-c",
Created: 1900000000,
State: "running",
Status: "Up 10 minutes",
Labels: map[string]string{
"com.getarcaneapp.internal.resource": "true",
},
},
}
images := []dockerimage.Summary{
{ID: "sha256:image-a", RepoTags: []string{"repo/app:stable"}, Created: 1710000000, Size: 100},
{ID: "sha256:image-b", RepoTags: []string{"repo/worker:latest"}, Created: 1720000000, Size: 250},
{ID: "sha256:image-c", RepoTags: []string{"ghcr.io/getarcaneapp/arcane:latest"}, Created: 1730000000, Size: 175},
}
createDashboardTestImageUpdateRecord(t, db, imageupdate.ImageUpdateRecord{
ID: "sha256:image-b",
Repository: "docker.io/repo/worker",
Tag: "latest",
HasUpdate: true,
})
// Recorded under another local tag of the running container's image.
createDashboardTestImageUpdateRecord(t, db, imageupdate.ImageUpdateRecord{
ID: "sha256:image-a",
Repository: "docker.io/repo/app",
Tag: "edge",
HasUpdate: true,
UpdateType: "digest",
})
createDashboardTestAPIKey(t, db, apikey.ApiKey{
Name: "expiring-soon",
KeyHash: "hash-soon",
KeyPrefix: "arc_test_snapshot",
UserID: new("user-1"),
ExpiresAt: new(time.Now().Add(12 * time.Hour)),
})
volumes := []dockervolume.Volume{
{Name: "app-data", Driver: "local"},
{Name: "orphan-data", Driver: "local"},
}
dockerSvc := newDashboardTestDockerService(t, settingsSvc, containers, images, volumes)
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "projectsDirectory", projectsDir))
require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "autoUpdateExcludedContainers", "stopped-app"))
projectPath := filepath.Join(projectsDir, "project-with-update")
require.NoError(t, os.MkdirAll(projectPath, 0o755))
require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: repo/worker:latest\n"), 0o644))
dirName := "project-with-update"
require.NoError(t, db.WithContext(t.Context()).Create(&project.Project{
ID: "project-with-update",
Name: "project-with-update",
DirName: &dirName,
Path: projectPath,
Status: project.ProjectStatusStopped,
}).Error)
imageSvc := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
projectSvc := project.NewProjectService(db, settingsSvc, nil, imageSvc, testDockerService, nil, nil, nil, config.Load(), nil, nil)
svc := NewDashboardService(
db,
dockerSvc,
nil,
projectSvc,
imageSvc,
settingsSvc,
nil,
nil,
nil,
volume.NewVolumeService(db, nil, nil, nil, nil, nil, nil, nil, nil, nil),
podman.NewService(podman.Config{Engine: dockerSvc.Engine}),
)
snapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.NotNil(t, snapshot)
require.Len(t, snapshot.Containers.Data, 2)
require.Equal(t, "container-stopped", snapshot.Containers.Data[0].ID)
require.False(t, snapshot.Containers.Data[0].AutoUpdateEnabled, "settings exclusion applies to dashboard summaries")
require.True(t, snapshot.Containers.Data[1].AutoUpdateEnabled)
require.Equal(t, 1, snapshot.Containers.Counts.RunningContainers)
require.Equal(t, 1, snapshot.Containers.Counts.StoppedContainers)
require.Equal(t, 2, snapshot.Containers.Counts.TotalContainers)
require.EqualValues(t, 2, snapshot.Containers.Pagination.TotalItems)
require.Len(t, snapshot.Images.Data, 3)
require.Equal(t, "sha256:image-b", snapshot.Images.Data[0].ID)
require.Equal(t, 2, snapshot.ImageUsageCounts.Inuse)
require.Equal(t, 1, snapshot.ImageUsageCounts.Unused)
require.Equal(t, 3, snapshot.ImageUsageCounts.Total)
require.EqualValues(t, 525, snapshot.ImageUsageCounts.TotalSize)
require.Equal(t, dashboard.SnapshotSettings{}, snapshot.Settings)
require.NotNil(t, snapshot.VolumeUsageCounts)
require.Equal(t, volumetypes.UsageCounts{Inuse: 1, Unused: 1, Total: 2}, *snapshot.VolumeUsageCounts)
require.ElementsMatch(t, []dashboard.ActionItem{
{Kind: dashboard.ActionItemKindStoppedContainers, Count: 1, Severity: dashboard.ActionItemSeverityWarning},
{Kind: dashboard.ActionItemKindImageUpdates, Count: 3, Severity: dashboard.ActionItemSeverityWarning},
{Kind: dashboard.ActionItemKindExpiringKeys, Count: 1, Severity: dashboard.ActionItemSeverityWarning},
}, snapshot.ActionItems.Items, "the excluded stopped container, the moving-tag container, and the project each count once")
}
func TestDashboardService_GetSnapshot_DebugAllGoodOnlyClearsActionItems(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
containers := []dockercontainer.Summary{
{
ID: "container-stopped",
Names: []string{"/stopped-app"},
Image: "repo/worker:latest",
ImageID: "sha256:image-b",
Created: 1800000000,
State: "exited",
Status: "Exited (0) 1 hour ago",
Labels: map[string]string{},
},
}
images := []dockerimage.Summary{
{ID: "sha256:image-b", RepoTags: []string{"repo/worker:latest"}, Created: 1720000000, Size: 250},
}
createDashboardTestImageUpdateRecord(t, db, imageupdate.ImageUpdateRecord{ID: "sha256:image-b", HasUpdate: true})
dockerSvc := newDashboardTestDockerService(t, settingsSvc, containers, images, nil)
svc := NewDashboardService(db, dockerSvc, nil, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{Engine: dockerSvc.Engine}))
snapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{DebugAllGood: true}, true)
require.NoError(t, err)
require.NotNil(t, snapshot)
require.Len(t, snapshot.Containers.Data, 1)
require.Len(t, snapshot.Images.Data, 1)
require.Equal(t, 1, snapshot.Containers.Counts.StoppedContainers)
require.Equal(t, 1, snapshot.ImageUsageCounts.Inuse)
require.Nil(t, snapshot.VolumeUsageCounts)
require.Empty(t, snapshot.ActionItems.Items)
}
func TestDashboardService_GetSnapshot_EnrichesPinnedReferences(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
pinnedRef := "ghcr.io/syncthing/syncthing:2.1.3@sha256:8c8ff37ab6aa8be23b700648a90fa9412e214852e9fd6ea8477c8334792daec0"
containers := []dockercontainer.Summary{
{
ID: "container-syncthing",
Names: []string{"/syncthing"},
Image: pinnedRef,
ImageID: "sha256:image-syncthing",
Created: 1800000000,
State: "running",
Status: "Up 1 hour",
Labels: map[string]string{},
},
}
images := []dockerimage.Summary{
{
ID: "sha256:image-syncthing",
RepoTags: []string{},
RepoDigests: []string{"ghcr.io/syncthing/syncthing@sha256:8c8ff37ab6aa8be23b700648a90fa9412e214852e9fd6ea8477c8334792daec0"},
Created: 1720000000,
Size: 250,
},
}
dockerSvc := newDashboardTestDockerService(t, settingsSvc, containers, images, nil)
svc := NewDashboardService(db, dockerSvc, nil, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{Engine: dockerSvc.Engine}))
snapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.NotNil(t, snapshot)
require.Len(t, snapshot.Images.Data, 1)
assert.Equal(t, "sha256:image-syncthing", snapshot.Images.Data[0].ID)
assert.Equal(t, "ghcr.io/syncthing/syncthing", snapshot.Images.Data[0].Repo)
assert.Equal(t, "<none>", snapshot.Images.Data[0].Tag)
assert.Equal(t, []string{pinnedRef}, snapshot.Images.Data[0].PinnedReferences)
}
func TestDashboardService_GetSnapshot_TrimmedOmitsTablesAndSharesBuilds(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
containers := []dockercontainer.Summary{
{
ID: "container-running",
Names: []string{"/running-app"},
Image: "repo/app:stable",
ImageID: "sha256:image-a",
Created: 1700000000,
State: "running",
Status: "Up 2 hours",
Labels: map[string]string{},
},
{
ID: "container-stopped",
Names: []string{"/stopped-app"},
Image: "repo/worker:latest",
ImageID: "sha256:image-b",
Created: 1800000000,
State: "exited",
Status: "Exited (0) 1 hour ago",
Labels: map[string]string{},
},
}
images := []dockerimage.Summary{
{ID: "sha256:image-a", RepoTags: []string{"repo/app:stable"}, Created: 1710000000, Size: 100},
{ID: "sha256:image-b", RepoTags: []string{"repo/worker:latest"}, Created: 1720000000, Size: 250},
}
dockerSvc := newDashboardTestDockerService(t, settingsSvc, containers, images, nil)
svc := NewDashboardService(db, dockerSvc, nil, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{Engine: dockerSvc.Engine}))
trimmed, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, false)
require.NoError(t, err)
require.NotNil(t, trimmed)
// No table rows, but counters and pagination totals intact.
require.Nil(t, trimmed.Containers.Data)
require.Nil(t, trimmed.Images.Data)
require.Equal(t, 1, trimmed.Containers.Counts.RunningContainers)
require.Equal(t, 1, trimmed.Containers.Counts.StoppedContainers)
require.Equal(t, 2, trimmed.Containers.Counts.TotalContainers)
require.EqualValues(t, 2, trimmed.Containers.Pagination.TotalItems)
require.EqualValues(t, 2, trimmed.Images.Pagination.TotalItems)
require.Equal(t, 2, trimmed.ImageUsageCounts.Total)
// Within the TTL every subscriber shares the same build.
again, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, false)
require.NoError(t, err)
require.Same(t, trimmed, again)
// The full variant is cached separately and still carries the tables.
full, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.NotNil(t, full)
require.Len(t, full.Containers.Data, 2)
require.Len(t, full.Images.Data, 2)
}
func TestDashboardService_GetSnapshot_CachesFullSnapshotsPerIconCatalog(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
containers := []dockercontainer.Summary{
{
ID: "container-running",
Names: []string{"/running-app"},
Image: "repo/app:stable",
ImageID: "sha256:image-a",
Created: 1700000000,
State: "running",
Status: "Up 2 hours",
Labels: map[string]string{"arcane.icon": "myapp"},
},
}
images := []dockerimage.Summary{
{ID: "sha256:image-a", RepoTags: []string{"repo/app:stable"}, Created: 1710000000, Size: 100},
}
dockerSvc := newDashboardTestDockerService(t, settingsSvc, containers, images, nil)
require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "autoUpdateExcludedContainers", "running-app"))
containerSvc := container.NewContainerService(nil, dockerSvc, nil, settingsSvc, nil, nil, nil)
svc := NewDashboardService(db, dockerSvc, containerSvc, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{Engine: dockerSvc.Engine}))
defaultSnapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.Len(t, defaultSnapshot.Containers.Data, 1)
require.Contains(t, defaultSnapshot.Containers.Data[0].IconLightURL, "selfhst")
require.False(t, defaultSnapshot.Containers.Data[0].AutoUpdateEnabled, "container service summaries honor the settings exclusion")
// A user preferring another catalog must not be served the default-catalog
// snapshot from the cache.
dashboardIconsUser := &user.Actor{Preferences: user.Preferences{IconCatalog: new("dashboard-icons")}}
userCtx := context.WithValue(t.Context(), user.CurrentUserContextKey{}, dashboardIconsUser)
userSnapshot, err := svc.GetSnapshot(userCtx, DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.NotSame(t, defaultSnapshot, userSnapshot)
require.Len(t, userSnapshot.Containers.Data, 1)
require.Contains(t, userSnapshot.Containers.Data[0].IconLightURL, "dashboard-icons")
// Both catalog variants stay cached side by side within the TTL.
defaultAgain, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.Same(t, defaultSnapshot, defaultAgain)
userAgain, err := svc.GetSnapshot(userCtx, DashboardActionItemsOptions{}, true)
require.NoError(t, err)
require.Same(t, userSnapshot, userAgain)
}
func TestPendingContainerCountUsesScopedTagRecords(t *testing.T) {
db, _ := setupDashboardServiceTestDB(t)
tagLabels := map[string]string{labels.LabelUpdateStrategy: "auto"}
records := []imageupdate.ImageUpdateRecord{
// A digest record recorded under another local tag of the shared image.
{ID: "shared", Repository: "docker.io/library/app", Tag: "stable", HasUpdate: true, UpdateType: "digest"},
{ID: "container::first", PolicyKey: imageref.UpdatePolicyKey("app:1.2.3", tagLabels), ContainerID: "first", ImageID: "shared", HasUpdate: true, UpdateType: "tag"},
{
ID: "container::other-project",
PolicyKey: imageref.UpdatePolicyKey(
"app:1.2.3",
tagLabels,
),
ContainerID: "other-project",
ImageID: "shared",
HasUpdate: true,
UpdateType: "tag",
},
}
require.NoError(t, db.Create(&records).Error)
service := &DashboardService{db: db, imageService: image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)}
containers := []dockercontainer.Summary{
{ID: "first", Image: "app:1.2.3", ImageID: "shared", Labels: map[string]string{labels.LabelUpdateStrategy: "auto"}},
{ID: "unchecked", Image: "app:1.2.3", ImageID: "shared", Labels: map[string]string{labels.LabelUpdateStrategy: "auto"}},
}
count, err := service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 1, count)
containers = append(containers, dockercontainer.Summary{ID: "digest", Image: "app:latest", ImageID: "shared"})
count, err = service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 2, count, "a digest record under another tag of the running image counts")
containers = append(containers, dockercontainer.Summary{ID: "digest-twin", Image: "app:latest", ImageID: "shared"})
count, err = service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 3, count, "separate containers sharing one image each count once")
containers[0].Labels[labels.LabelUpdater] = "off"
count, err = service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 3, count, "disabling automatic installation keeps the pending update visible")
containers[0].Labels[imageref.UpdateCheckLabel] = "false"
count, err = service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 2, count, "disabling update checks suppresses the result")
containers[2].ImageID = ""
count, err = service.getPendingContainerUpdatesCount(t.Context(), containers)
require.NoError(t, err)
require.Equal(t, 1, count, "a missing runtime image ID inherits no digest check")
}
func TestDashboardService_ReportsPodmanPods(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
dockerSvc := newDashboardTestDockerService(t, settingsSvc, nil, nil, nil)
libpodServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch r.URL.Path {
case "/v4.0.0/libpod/version":
_, _ = w.Write([]byte(`{"Version":"6.1.0","ApiVersion":"6.1.0"}`))
case "/v4.0.0/libpod/info":
_, _ = w.Write([]byte(`{"host":{"security":{"rootless":false}}}`))
case "/v4.0.0/libpod/pods/json":
_, _ = w.Write([]byte(`[{"Id":"pod-a","Name":"web"},{"Id":"pod-b","Name":"db"}]`))
default:
http.NotFound(w, r)
}
}))
t.Cleanup(libpodServer.Close)
svc := NewDashboardService(db, dockerSvc, nil, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{
Engine: func(context.Context) (compat.EngineCompatibilityInfo, error) {
return compat.EngineCompatibilityInfo{Name: "podman"}, nil
},
Host: libpodServer.URL,
NewSystemd: func(rootless bool) libpodman.Systemd {
return libpodman.NewSystemd("", rootless, func(string) string {
return ""
})
},
}))
snapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, false)
require.NoError(t, err)
require.NotNil(t, snapshot.PodCount)
require.Equal(t, 2, *snapshot.PodCount)
reader := metric.NewManualReader()
provider := metric.NewMeterProvider(metric.WithReader(reader))
t.Cleanup(func() { require.NoError(t, provider.Shutdown(context.WithoutCancel(t.Context()))) })
require.NoError(t, svc.ObserveInventory(provider.Meter("dashboard-test")))
var collected metricdata.ResourceMetrics
require.NoError(t, reader.Collect(t.Context(), &collected))
var pods []metricdata.DataPoint[int64]
for _, scope := range collected.ScopeMetrics {
for _, m := range scope.Metrics {
if gauge, ok := m.Data.(metricdata.Gauge[int64]); ok && m.Name == "arcane.podman.pods" {
pods = gauge.DataPoints
}
}
}
require.Len(t, pods, 1)
require.Equal(t, int64(2), pods[0].Value)
}
func TestDashboardService_OmitsPodCountOnDocker(t *testing.T) {
db, settingsSvc := setupDashboardServiceTestDB(t)
dockerSvc := newDashboardTestDockerService(t, settingsSvc, nil, nil, nil)
svc := NewDashboardService(db, dockerSvc, nil, nil, nil, settingsSvc, nil, nil, nil, nil, podman.NewService(podman.Config{
Engine: func(context.Context) (compat.EngineCompatibilityInfo, error) {
return compat.EngineCompatibilityInfo{Name: "docker"}, nil
},
}))
snapshot, err := svc.GetSnapshot(t.Context(), DashboardActionItemsOptions{}, false)
require.NoError(t, err)
require.Nil(t, snapshot.PodCount)
}