Skip to content

Modern Docker Management, Designed for Everyone

20.9 KB
Raw Blame
package containers_test

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	kit "go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/testutil"
)

func TestContainerStartSurfacesServerError(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && r.URL.Path == "/api/environments/0/containers/abc123":
			// Resolution succeeds so the action POST below is reached.
			w.Header().Set("Content-Type", "application/json")
			_, _ = w.Write([]byte(`{"success":true,"data":{"id":"abc123","name":"nginx"}}`))
		case r.Method == http.MethodPost && r.URL.Path == "/api/environments/0/containers/abc123/start":
			w.WriteHeader(http.StatusForbidden)
			_, _ = w.Write([]byte(`{"success":false,"data":{"error":"permission denied: containers:start"}}`))
		default:
			w.WriteHeader(http.StatusNotFound)
			_, _ = w.Write([]byte(`{"success":false,"error":"not found"}`))
		}
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)
	outBuf, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "containers", "start", "abc123"},
	)

	require.Error(t, err,
		"expected an error for a 403 start response, got success\nstdout=%s\nstderr=%s", outBuf, errOut)

	require.Contains(t, err.Error(), "403",
		"expected the error to mention status 403, got: %v", err)

	require.NotContains(t, outBuf, "successfully",
		"expected no success message on a denied start, got stdout=%s", outBuf)
	for _, tc := range []struct {
		name        string
		identifier  string
		duplicate   bool
		unavailable bool
		search      bool
		prefix      bool
		explicit    bool
	}{
		{name: "unique environment", identifier: "abc123"},
		{name: "duplicate ID", identifier: "abc123", duplicate: true},
		{name: "partial search", identifier: "abc123", unavailable: true},
		{name: "name search", identifier: "nginx", search: true},
		{name: "ID prefix fallback", identifier: "abcd", prefix: true},
		{name: "explicit environment", identifier: "abc123", duplicate: true, explicit: true},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var mu sync.Mutex
			var mutations []string
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", "application/json")
				if r.URL.Path == "/api/environments" {
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"0","name":"Local","enabled":true},{"id":"remote","name":"Remote","enabled":true}]}`))
					return
				}
				if r.Method == http.MethodPost {
					mu.Lock()
					mutations = append(mutations, r.URL.Path)
					mu.Unlock()
					_, _ = w.Write([]byte(`{"success":true,"data":{"message":"started"}}`))
					return
				}
				local := strings.Contains(r.URL.Path, "/0/")
				if local && tc.unavailable {
					w.WriteHeader(http.StatusForbidden)
					_, _ = w.Write([]byte(`{"success":false,"error":"search denied"}`))
					return
				}
				switch {
				case strings.HasSuffix(r.URL.Path, "/containers") && !local && (tc.search || tc.prefix && r.URL.Query().Get("search") == ""):
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"abcd1234","names":["/nginx"]}]}`))
					return
				case strings.HasSuffix(r.URL.Path, "/containers"):
					_, _ = w.Write([]byte(`{"success":true,"data":[]}`))
					return
				case (!local || tc.duplicate) && !tc.search && !tc.prefix:
					_, _ = w.Write([]byte(`{"success":true,"data":{"id":"abc123","name":"nginx"}}`))
					return
				}
				w.WriteHeader(http.StatusNotFound)
				_, _ = w.Write([]byte(`{"success":false,"error":"not found"}`))
			}))
			defer server.Close()
			path := testutil.WriteConfig(t, server.URL, true)
			args := []string{"--config", path, "--json", "--yes"}
			if tc.explicit {
				args = append(args, "--env", "remote")
			}
			out, diagnostics, runErr := testutil.Execute(t, append(args, "containers", "start", tc.identifier))
			mu.Lock()
			paths := append([]string(nil), mutations...)
			mu.Unlock()
			if !tc.explicit && (tc.duplicate || tc.unavailable) {
				require.ErrorContains(t, runErr, "pass --env")
				require.Empty(t, paths)
				require.Empty(t, out)
				return
			}
			require.NoError(t, runErr, diagnostics)
			resourceID := "abc123"
			if tc.search || tc.prefix {
				resourceID = "abcd1234"
			}
			require.Equal(t, []string{"/api/environments/remote/containers/" + resourceID + "/start"}, paths)
			var result map[string]any
			require.NoError(t, json.Unmarshal([]byte(out), &result), out)
			require.NotContains(t, result, "environments")
		})
	}
}

func TestContainersListSendsLimitAndStart(t *testing.T) {
	for _, tc := range []struct {
		name         string
		preview, all bool
	}{
		{name: "saved environment"}, {name: "preview pagination", preview: true}, {name: "preview all", preview: true, all: true},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var mu sync.Mutex
			queries := make(map[string]string)
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", "application/json")
				if r.URL.Path == "/api/environments" {
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"0","name":"Local","enabled":true},{"id":"remote","name":"Remote","enabled":true}]}`))
					return
				}
				mu.Lock()
				queries[r.URL.Path] = r.URL.RawQuery
				mu.Unlock()
				_, _ = w.Write([]byte(`{"success":true,"data":[],"pagination":{"totalPages":4,"totalItems":20,"currentPage":3,"itemsPerPage":5}}`))
			}))
			defer server.Close()
			args := []string{"--config", testutil.WriteConfig(t, server.URL, tc.preview), "containers", "list", "--json"}
			if tc.all {
				args = append(args, "--all")
			} else {
				args = append(args, "--limit", "5", "--start", "10")
			}
			out, diagnostics, err := testutil.Execute(t, args)
			require.NoError(t, err, diagnostics)
			mu.Lock()
			defer mu.Unlock()
			wantQuery := "limit=5&start=10"
			if tc.all {
				wantQuery = "limit=-1"
			}
			require.Equal(t, map[string]string{kit.Ternary(tc.preview, "/api/environments/0,remote/containers", "/api/environments/0/containers"): wantQuery}, queries)
			require.True(t, json.Valid([]byte(out)))
			require.Contains(t, out, "pagination")
		})
	}
}

func TestContainersListExplicitStartZeroSendsStartZero(t *testing.T) {
	var (
		mu       sync.Mutex
		gotPath  string
		gotQuery string
	)

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		mu.Lock()
		gotPath = r.URL.Path
		gotQuery = r.URL.RawQuery
		mu.Unlock()

		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{
			"success": true,
			"data": [],
			"pagination": {"totalPages":2,"totalItems":26,"currentPage":1,"itemsPerPage":20}
		}`))
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)
	_, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "containers", "list", "--json", "--start", "0"},
	)

	require.NoError(t, err,
		"execute: %v (%s)", err, errOut)

	mu.Lock()
	defer mu.Unlock()

	require.Equal(t, "/api/environments/0/containers", gotPath,
		"path = %q, want %q", gotPath, "/api/environments/0/containers")

	require.True(t, strings.Contains(gotQuery, "start=0") && strings.Contains(gotQuery, "limit=20"),
		"query = %q, want start=0 and limit=20", gotQuery)
}

func TestContainersListTextShowsShowingSummary(t *testing.T) {
	const localRow = `{"environmentId":"0","environmentName":"Local","id":"same-id","names":["/nginx"],"image":"nginx:latest","state":"running","status":"Up 1 hour"}`
	for _, tc := range []struct {
		name                                  string
		command                               []string
		preview, unavailable, empty, explicit bool
		summary                               string
	}{
		{name: "single environment", summary: "Showing: 1/26 containers"},
		{name: "combined environments", preview: true, summary: "Showing: 2/52 containers"},
		{name: "partial failure", preview: true, unavailable: true, summary: "Showing: 1/26 containers"},
		{name: "empty resources", preview: true, empty: true, summary: "Showing: 0/0 containers"},
		{name: "explicit override", preview: true, explicit: true, summary: "Showing: 1/26 containers"},
		{name: "custom jobs", preview: true, command: []string{"jobs", "list"}, summary: "Total: 2 jobs"},
		{name: "custom settings", preview: true, command: []string{"settings", "list"}, summary: "Total: 2 settings"},
	} {
		t.Run(tc.name, func(t *testing.T) {
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", "application/json")
				switch {
				case r.URL.Path == "/api/environments":
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"remote","name":"Remote","enabled":true},{"id":"0","name":"Local","enabled":true}]}`))
				case tc.empty:
					_, _ = w.Write([]byte(`{"success":true,"data":[],"pagination":{"totalItems":0}}`))
				case r.URL.Path == "/api/environments/0,remote/containers" && tc.unavailable:
					_, _ = w.Write([]byte(`{"success":true,"data":[` + localRow + `],"pagination":{"totalItems":26},` +
						`"failedEnvironments":[{"environment":{"id":"remote","name":"remote"},"message":"resource denied"}]}`))
				case r.URL.Path == "/api/environments/0,remote/containers":
					remoteRow := strings.Replace(localRow, `"0","environmentName":"Local"`, `"remote","environmentName":"Remote"`, 1)
					_, _ = w.Write([]byte(`{"success":true,"data":[` + localRow + `,` + remoteRow + `],"pagination":{"totalItems":52}}`))
				case strings.HasSuffix(r.URL.Path, "/jobs"):
					_, _ = w.Write([]byte(`{"jobs":[{"id":"same-id","name":"nginx"}],"isAgent":false,"durableRuns":true}`))
				case strings.HasSuffix(r.URL.Path, "/settings"):
					_, _ = w.Write([]byte(`[{"key":"nginx","value":"dark","type":"string"}]`))
				default:
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"same-id","names":["/nginx"],"image":"nginx:latest","state":"running","status":"Up 1 hour"}],"pagination":{"totalItems":26}}`))
				}
			}))
			defer srv.Close()
			configPath := testutil.WriteConfig(t, srv.URL, tc.preview)
			args := []string{"--config", configPath, "--no-color"}
			if tc.explicit {
				args = append(args, "--env", "remote")
			}
			command := tc.command
			if command == nil {
				command = []string{"containers", "list"}
			}
			out, diagnostics, err := testutil.Execute(t, append(args, command...))
			if tc.unavailable {
				require.ErrorContains(t, err, "resource denied")
			} else {
				require.NoError(t, err, diagnostics)
			}
			require.Contains(t, out, tc.summary)
			require.Equal(t, 1, strings.Count(out, tc.summary))
			require.NotContains(t, out, "\x1b")
			if !tc.preview || tc.explicit {
				require.NotContains(t, out, "ENVIRONMENT")
				return
			}
			require.Equal(t, 1, strings.Count(out, "ENVIRONMENT"), out)
			require.Equal(t, 1, strings.Count(out, "TYPE")+strings.Count(out, "NAME"), out)
			if tc.empty {
				require.NotContains(t, out, "nginx")
				return
			}
			require.Contains(t, out, "Local")
			require.NotContains(t, out, "(0)")
			require.NotContains(t, out, "(remote)")
			if tc.unavailable {
				require.NotContains(t, out, "Remote")
				require.Contains(t, diagnostics, "Remote (remote): resource denied")
				return
			}
			require.Contains(t, out, "Remote")
			require.Equal(t, 2, strings.Count(out, "Local")+strings.Count(out, "Remote"))
		})
	}
}

func TestContainersListAllRequestsEveryItem(t *testing.T) {
	var (
		mu       sync.Mutex
		gotPath  string
		gotQuery string
	)

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		mu.Lock()
		gotPath = r.URL.Path
		gotQuery = r.URL.RawQuery
		mu.Unlock()

		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{
			"success": true,
			"data": [],
			"pagination": {"totalPages":1,"totalItems":0,"currentPage":1,"itemsPerPage":0}
		}`))
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)
	_, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "containers", "list", "--json", "--all"},
	)

	require.NoError(t, err,
		"execute: %v (%s)", err, errOut)

	mu.Lock()
	defer mu.Unlock()

	require.Equal(t, "/api/environments/0/containers", gotPath,
		"path = %q, want %q", gotPath, "/api/environments/0/containers")

	require.Equal(t, "limit=-1", gotQuery,
		"query = %q, want %q", gotQuery, "limit=-1")
}

func TestContainersListJSONContract(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !strings.HasPrefix(r.URL.Path, "/api/environments/0/containers") {
			w.WriteHeader(http.StatusNotFound)
			_, _ = w.Write([]byte(`{"success":false,"error":"not found"}`))
			return
		}
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{
			"success": true,
			"data": [
				{"id":"abc123","names":["/nginx"],"image":"nginx:latest","state":"running","status":"Up 1 hour"}
			],
			"pagination": {"totalPages":1,"totalItems":1,"currentPage":1,"itemsPerPage":20}
		}`))
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)

	outBuf, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "--log-level", "debug", "containers", "list", "--json"},
	)

	require.NoError(t, err,
		"execute: %v (%s)", err, errOut)

	require.Contains(t, errOut, "Sending request")
	require.NotContains(t, outBuf, "Sending request")
	require.NotContains(t, outBuf, "\x1b")
	var got map[string]any
	{
		unmarshalErr := json.Unmarshal([]byte(strings.TrimSpace(outBuf)), &got)
		require.NoError(t, unmarshalErr,
			"json parse failed: %v\noutput=%s", unmarshalErr, outBuf)
	}

	for _, key := range []string{"success", "data", "pagination"} {
		require.Contains(t, got, key)
	}
	for _, tc := range []struct {
		name             string
		args             []string
		unavailable      bool
		empty            bool
		discoveryFailure bool
		explicit         bool
	}{
		{name: "preview retains envelopes"},
		{name: "preview partial failure", unavailable: true},
		{name: "preview empty", empty: true},
		{name: "preview discovery failure", discoveryFailure: true},
		{name: "preview explicit override", explicit: true},
		{name: "preview custom job response", args: []string{"jobs", "list"}},
		{name: "preview settings response", args: []string{"settings", "list"}},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var mu sync.Mutex
			var requested []string
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				mu.Lock()
				requested = append(requested, r.URL.Path)
				mu.Unlock()
				w.Header().Set("Content-Type", "application/json")
				switch {
				case r.URL.Path == "/api/environments" && tc.discoveryFailure:
					w.WriteHeader(http.StatusForbidden)
					_, _ = w.Write([]byte(`{"success":false,"error":"discovery denied"}`))
					return
				case r.URL.Path == "/api/environments" && tc.empty:
					_, _ = w.Write([]byte(`{"success":true,"data":[]}`))
					return
				case r.URL.Path == "/api/environments":
					assert.Equal(t, "-1", r.URL.Query().Get("limit"))
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"remote","name":"Remote","enabled":true},{"id":"disabled","name":"Disabled","enabled":false},{"id":"0","name":"Local","enabled":true}]}`))
					return
				case tc.unavailable && strings.Contains(r.URL.Path, "/remote/"):
					w.WriteHeader(http.StatusForbidden)
					_, _ = w.Write([]byte(`{"success":false,"error":"resource denied"}`))
					return
				case r.URL.Path == "/api/environments/0,remote/containers" && tc.unavailable:
					_, _ = w.Write([]byte(`{"success":true,"data":[{"environmentId":"0","environmentName":"Local","id":"same-id"}],"pagination":{"totalItems":1},` +
						`"failedEnvironments":[{"environment":{"id":"remote","name":"remote"},"message":"resource denied"}]}`))
				case strings.HasSuffix(r.URL.Path, "/jobs"):
					_, _ = w.Write([]byte(`{"jobs":[],"isAgent":false,"durableRuns":true}`))
				case strings.HasSuffix(r.URL.Path, "/settings"):
					_, _ = w.Write([]byte(`[{"key":"theme","value":"dark","type":"string"}]`))
				default:
					_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"same-id","names":["/nginx"]}],"pagination":{"totalItems":1},"counts":{"running":1},"groups":["preserved"]}`))
				}
			}))
			defer server.Close()
			path := testutil.WriteConfig(t, server.URL, true)
			args := []string{"--config", path, "--json"}
			if tc.explicit {
				args = append(args, "--env", "remote")
			}
			command := tc.args
			if command == nil {
				command = []string{"containers", "list"}
			}
			out, diagnostics, runErr := testutil.Execute(t, append(args, command...))
			if tc.discoveryFailure {
				require.ErrorContains(t, runErr, "discovery denied")
				require.Empty(t, out)
				return
			}
			if tc.unavailable {
				require.ErrorContains(t, runErr, "resource denied")
			} else {
				require.NoError(t, runErr, diagnostics)
			}
			mu.Lock()
			paths := append([]string(nil), requested...)
			mu.Unlock()
			if tc.args == nil && !tc.explicit && !tc.empty {
				require.Equal(t, []string{"/api/environments", "/api/environments/0,remote/containers"}, paths)
				require.True(t, json.Valid([]byte(out)), out)
				if tc.unavailable {
					require.ErrorContains(t, runErr, "Remote (remote): resource denied")
					require.Contains(t, out, "failedEnvironments")
					return
				}
				require.Contains(t, out, "counts")
				require.Contains(t, out, "groups")
				return
			}
			var result struct {
				Success      bool `json:"success"`
				Environments []struct {
					ID     string          `json:"environmentId"`
					Result json.RawMessage `json:"result"`
					Error  string          `json:"error"`
				} `json:"environments"`
			}
			require.NoError(t, json.Unmarshal([]byte(out), &result), out)
			if tc.explicit {
				require.NotContains(t, paths, "/api/environments")
				require.Empty(t, result.Environments)
				require.Contains(t, out, "counts")
				return
			}
			require.Equal(t, !tc.unavailable, result.Success)
			require.NotContains(t, strings.Join(paths, ","), "disabled")
			if tc.empty {
				require.Empty(t, result.Environments)
				require.Len(t, paths, 1)
				return
			}
			require.Len(t, result.Environments, 2)
			require.Equal(t, "0", result.Environments[0].ID)
			require.Equal(t, "remote", result.Environments[1].ID)
			require.NotContains(t, out, "Selected")
		})
	}
}

func TestContainersListUpdatesJSONContract(t *testing.T) {
	seenUpdatesFilter := ""

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/environments/0/containers" {
			w.WriteHeader(http.StatusNotFound)
			_, _ = w.Write([]byte(`{"success":false,"error":"not found"}`))
			return
		}

		seenUpdatesFilter = r.URL.Query().Get("updates")
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{
			"success": true,
			"data": [
				{
					"id":"abc123",
					"names":["/nginx"],
					"image":"nginx:latest",
					"state":"running",
					"status":"Up 1 hour",
					"updateInfo":{"hasUpdate":true,"latestVersion":"1.28.0"}
				}
			],
			"pagination": {"totalPages":1,"totalItems":1,"currentPage":1,"itemsPerPage":20}
		}`))
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)
	outBuf, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "containers", "list", "--updates", "has_update", "--json"},
	)

	require.NoError(t, err,
		"execute: %v (%s)", err, errOut)

	require.Equal(t, "has_update", seenUpdatesFilter,
		"expected updates filter query param, got %q", seenUpdatesFilter)

	var got map[string]any
	{
		unmarshalErr := json.Unmarshal([]byte(strings.TrimSpace(outBuf)), &got)
		require.NoError(t, unmarshalErr,
			"json parse failed: %v\noutput=%s", unmarshalErr, outBuf)
	}

	for _, key := range []string{"success", "data", "pagination"} {
		{
			_, ok := got[key]
			require.True(t, ok,
				"missing key %q in output: %v", key, got)
		}
	}
}

func TestContainersUpdatesCommandUsesHasUpdateFilter(t *testing.T) {
	seenUpdatesFilter := ""

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/environments/0/containers" {
			w.WriteHeader(http.StatusNotFound)
			_, _ = w.Write([]byte(`{"success":false,"error":"not found"}`))
			return
		}

		seenUpdatesFilter = r.URL.Query().Get("updates")
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{
			"success": true,
			"data": [
				{
					"id":"abc123",
					"names":["/nginx"],
					"image":"nginx:latest",
					"state":"running",
					"status":"Up 1 hour",
					"updateInfo":{"hasUpdate":true,"latestVersion":"1.28.0"}
				}
			],
			"pagination": {"totalPages":1,"totalItems":1,"currentPage":1,"itemsPerPage":20}
		}`))
	}))
	defer srv.Close()

	configPath := testutil.WriteConfig(t, srv.URL)
	outBuf, errOut, err := testutil.Execute(
		t,
		[]string{"--config", configPath, "--output", "text", "containers", "updates"},
	)

	require.NoError(t, err,
		"execute: %v (%s)", err, errOut)

	require.Equal(t, "has_update", seenUpdatesFilter,
		"expected updates filter query param, got %q", seenUpdatesFilter)

	require.NotEmpty(t, strings.TrimSpace(outBuf),
		"expected output from containers updates command")
}