Skip to content

Modern Docker Management, Designed for Everyone

22.1 KB
Raw Blame
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)
}