Skip to content

Modern Docker Management, Designed for Everyone

5.6 KB
Raw Blame
package podman

import (
	"net/http"
	"net/http/httptest"
	"testing"

	podmantypes "github.com/getarcaneapp/arcane/types/v2/podman"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
)

func newTestClient(t *testing.T, handler http.HandlerFunc) *Client {
	t.Helper()
	server := httptest.NewServer(handler)
	t.Cleanup(server.Close)

	client, err := NewClient(server.URL)
	require.NoError(t, err)
	return client
}

func TestNewClient(t *testing.T) {
	tests := []struct {
		name    string
		host    string
		baseURL string
		wantErr bool
	}{
		{name: "unix", host: "unix:///run/podman/podman.sock", baseURL: "http://podman"},
		{name: "tcp", host: "tcp://10.0.0.5:8888", baseURL: "http://10.0.0.5:8888"},
		{name: "https", host: "https://podman.example:8443", baseURL: "https://podman.example:8443"},
		{name: "unsupported", host: "ssh://user@host", wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			client, err := NewClient(tt.host)
			if tt.wantErr {
				require.ErrorIs(t, err, common.ErrBadRequest)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, tt.baseURL, client.baseURL)
		})
	}
}

func TestDetectFeatures(t *testing.T) {
	tests := []struct {
		name             string
		version          string
		systemdAvailable bool
		want             Features
	}{
		{
			name:             "podman 4 with systemd",
			version:          "4.9.4",
			systemdAvailable: true,
			want:             Features{AutoUpdateMode: podmantypes.AutoUpdateModeSystemd},
		},
		{
			name:    "podman 5.7 without systemd",
			version: "5.7.1",
			want:    Features{AutoUpdateMode: podmantypes.AutoUpdateModeUnavailable},
		},
		{
			name:             "podman 5.8",
			version:          "5.8.0",
			systemdAvailable: true,
			want: Features{
				QuadletsSupported: true,
				AutoUpdateMode:    podmantypes.AutoUpdateModeSystemd,
			},
		},
		{
			name:    "podman 6.1 with v prefix",
			version: "v6.1.2",
			want: Features{
				QuadletsSupported:    true,
				QuadletAppsSupported: true,
				AutoUpdateMode:       podmantypes.AutoUpdateModeUnavailable,
			},
		},
		{
			name:    "podman 6.2 uses rest",
			version: "6.2.0",
			want: Features{
				QuadletsSupported:    true,
				QuadletAppsSupported: true,
				AutoUpdateMode:       podmantypes.AutoUpdateModeREST,
			},
		},
		{
			name:             "invalid version",
			version:          "unknown",
			systemdAvailable: true,
			want:             Features{AutoUpdateMode: podmantypes.AutoUpdateModeSystemd},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, tt.want, DetectFeatures(tt.version, tt.systemdAvailable))
		})
	}
}

func TestClientVersionAndInfo(t *testing.T) {
	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/v4.0.0/libpod/version":
			_, _ = w.Write([]byte(`{"Version":"5.8.1","ApiVersion":"1.41","Components":[{"Name":"Podman Engine","Version":"5.8.1"}]}`))
		case "/v4.0.0/libpod/info":
			_, _ = w.Write([]byte(`{"host":{"hostname":"box","security":{"rootless":true}},"store":{"containerStore":{"number":3}},"version":{"APIVersion":"5.8.1","Version":"5.8.1"}}`))
		default:
			http.NotFound(w, r)
		}
	})

	version, err := client.Version(t.Context())
	require.NoError(t, err)
	assert.Equal(t, "5.8.1", version.Version)
	assert.Equal(t, "1.41", version.APIVersion)
	require.Len(t, version.Components, 1)
	assert.Equal(t, "Podman Engine", version.Components[0].Name)

	info, err := client.Info(t.Context())
	require.NoError(t, err)
	assert.True(t, info.Host.Security.Rootless)
	assert.Equal(t, "box", info.Host.Hostname)
	assert.Equal(t, 3, info.Store.ContainerStore.Number)
	assert.Equal(t, "5.8.1", info.Version.APIVersion)
}

func TestClientContainerList(t *testing.T) {
	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		assert.Equal(t, "/v4.0.0/libpod/containers/json", r.URL.Path)
		assert.Equal(t, "true", r.URL.Query().Get("all"))
		assert.JSONEq(t, `{"label":["PODMAN_SYSTEMD_UNIT=web.service"]}`, r.URL.Query().Get("filters"))
		_, _ = w.Write([]byte(`[{"Id":"abc","Names":["web"],"Labels":{"PODMAN_SYSTEMD_UNIT":"web.service"},"PodName":"","IsInfra":false,` +
			`"Ports":[{"host_ip":"127.0.0.1","container_port":80,"host_port":8080,"range":1,"protocol":"tcp"}]}]`))
	})

	containers, err := client.ContainerList(t.Context(), []string{podmantypes.SystemdUnitLabel + "=web.service"}, nil)
	require.NoError(t, err)
	require.Len(t, containers, 1)
	assert.Equal(t, "abc", containers[0].ID)
	assert.Equal(t, "web.service", containers[0].Labels[podmantypes.SystemdUnitLabel])
	assert.Equal(t, []podmantypes.PodPortMapping{
		{
			ContainerPort: 80,
			HostPort:      8080,
			HostIP:        "127.0.0.1",
			Protocol:      "tcp",
			Range:         1,
		},
	}, containers[0].Ports)
}

func TestClientErrorClassification(t *testing.T) {
	tests := []struct {
		name   string
		status int
		kind   error
	}{
		{name: "not found", status: http.StatusNotFound, kind: common.ErrNotFound},
		{name: "conflict", status: http.StatusConflict, kind: common.ErrConflict},
		{name: "bad request", status: http.StatusBadRequest, kind: common.ErrBadRequest},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			client := newTestClient(t, func(w http.ResponseWriter, _ *http.Request) {
				w.WriteHeader(tt.status)
				_, _ = w.Write([]byte(`{"cause":"no such pod","message":"pod web: no such pod","response":0}`))
			})

			_, err := client.PodInspect(t.Context(), "web")
			require.ErrorIs(t, err, tt.kind)
			assert.Contains(t, err.Error(), "pod web: no such pod")
		})
	}
}