generic_manager_test.go

package managers

import (
	"context"
	"errors"
	"path/filepath"
	"testing"

	"github.com/git-pkgs/managers/definitions"
)

func newTestManager(def *definitions.Definition, runner *MockRunner) *GenericManager {
	translator := NewTranslator()
	translator.Register(def)
	return &GenericManager{
		def:        def,
		dir:        "/test/project",
		translator: translator,
		runner:     runner,
	}
}

func embeddedDef(t *testing.T, name string) *definitions.Definition {
	t.Helper()
	defs, err := definitions.LoadEmbedded()
	if err != nil {
		t.Fatalf("LoadEmbedded: %v", err)
	}
	for _, d := range defs {
		if d.Name == name {
			return d
		}
	}
	t.Fatalf("no embedded definition %q", name)
	return nil
}

func TestGenericManager_Add_GomodVersion(t *testing.T) {
	runner := NewMockRunner()
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	_, err := mgr.Add(context.Background(), "github.com/pkg/errors", AddOptions{Version: "v0.9.1"})
	if err != nil {
		t.Fatalf("Add: %v", err)
	}
	want := []string{"go", "get", "github.com/pkg/errors@v0.9.1"}
	if !slicesEqual(runner.Captured[0], want) {
		t.Errorf("got %v, want %v", runner.Captured[0], want)
	}
}

func TestGenericManager_Add_CargoVersion(t *testing.T) {
	runner := NewMockRunner()
	mgr := newTestManager(embeddedDef(t, "cargo"), runner)
	_, err := mgr.Add(context.Background(), "serde", AddOptions{Version: "1.0.219"})
	if err != nil {
		t.Fatalf("Add: %v", err)
	}
	want := []string{"cargo", "add", "serde@1.0.219"}
	if !slicesEqual(runner.Captured[0], want) {
		t.Errorf("got %v, want %v", runner.Captured[0], want)
	}
}

func TestGenericManager_Add_RunsThenChain(t *testing.T) {
	runner := NewMockRunner()
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	res, err := mgr.Add(context.Background(), "github.com/pkg/errors", AddOptions{})
	if err != nil {
		t.Fatalf("Add: %v", err)
	}
	if len(runner.Captured) != 2 {
		t.Fatalf("captured %d commands, want 2 (go get + go mod tidy)", len(runner.Captured))
	}
	if !slicesEqual(runner.Captured[0], []string{"go", "get", "github.com/pkg/errors"}) {
		t.Errorf("cmd[0] = %v", runner.Captured[0])
	}
	if !slicesEqual(runner.Captured[1], []string{"go", "mod", "tidy"}) {
		t.Errorf("cmd[1] = %v", runner.Captured[1])
	}
	if !slicesEqual(res.Command, runner.Captured[0]) {
		t.Errorf("res.Command = %v, want the primary go get", res.Command)
	}
	if len(res.Then) != 1 || !slicesEqual(res.Then[0].Command, runner.Captured[1]) {
		t.Errorf("res.Then = %+v, want the go mod tidy result", res.Then)
	}
	if !res.Success() {
		t.Error("Success() should be true when all chain commands exit zero")
	}
}

func TestGenericManager_Add_ChainNilFollowupError(t *testing.T) {
	// A Runner that returns (nil, err) for the second call, as
	// PolicyRunner does on a policy violation.
	runner := NewMockRunner()
	runner.Results = []*Result{{Command: []string{"go", "get", "x"}, ExitCode: 0}}
	runner.Errors = []error{nil, errors.New("policy denied")}
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	res, err := mgr.Add(context.Background(), "example.com/x", AddOptions{})
	if err == nil {
		t.Fatal("expected error from follow-up")
	}
	if res == nil {
		t.Fatal("expected first command's result")
	}
	for _, th := range res.Then {
		if th == nil {
			t.Fatal("Then must not contain nil entries")
		}
	}
	// Success() must not panic; its value is not asserted since the
	// failure is signalled via the returned error, not the Result.
	_ = res.Success()
}

func TestGenericManager_Add_ChainStopsOnFailure(t *testing.T) {
	runner := NewMockRunner()
	runner.Results = []*Result{
		{Command: []string{"go", "get", "x"}, ExitCode: 1, Stderr: "boom"},
	}
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	res, err := mgr.Add(context.Background(), "example.com/x", AddOptions{})
	if err != nil {
		t.Fatalf("Add: %v", err)
	}
	if res.Success() {
		t.Error("Success() should be false when first command exits non-zero")
	}
	if len(runner.Captured) != 1 {
		t.Errorf("captured %d commands, want 1 (chain should stop)", len(runner.Captured))
	}
}

func TestGenericManager_Add_ChainThenFails(t *testing.T) {
	runner := NewMockRunner()
	runner.Results = []*Result{
		{Command: []string{"go", "get", "x"}, ExitCode: 0},
		{Command: []string{"go", "mod", "tidy"}, ExitCode: 1, Stderr: "tidy failed"},
	}
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	res, err := mgr.Add(context.Background(), "example.com/x", AddOptions{})
	if err != nil {
		t.Fatalf("Add: %v", err)
	}
	if res.Success() {
		t.Error("Success() should be false when a then: command exits non-zero")
	}
	if !slicesEqual(res.Command, []string{"go", "get", "x"}) {
		t.Errorf("res.Command = %v, want the primary command", res.Command)
	}
	if len(res.Then) != 1 {
		t.Fatalf("res.Then = %d, want 1", len(res.Then))
	}
	if res.Then[0].ExitCode != 1 || res.Then[0].Stderr != "tidy failed" {
		t.Errorf("res.Then[0] = %+v", res.Then[0])
	}
}

func TestGenericManager_Replace_RunsChain(t *testing.T) {
	runner := NewMockRunner()
	mgr := newTestManager(embeddedDef(t, "gomod"), runner)
	res, err := mgr.Replace(context.Background(), "example.com/x", ReplaceOptions{Path: "../x"})
	if err != nil {
		t.Fatalf("Replace: %v", err)
	}
	// gomod Replace runs `go mod edit -replace ...` then `go mod tidy`
	// as two separate operations; both must be reachable via Then.
	if len(runner.Captured) != 2 {
		t.Fatalf("captured %d commands, want 2", len(runner.Captured))
	}
	if !slicesEqual(runner.Captured[1], []string{"go", "mod", "tidy"}) {
		t.Errorf("cmd[1] = %v, want go mod tidy", runner.Captured[1])
	}
	if len(res.Then) != 1 || !slicesEqual(res.Then[0].Command, runner.Captured[1]) {
		t.Errorf("res.Then = %+v, want the tidy result", res.Then)
	}
}

func TestGenericManager_Replace_RunsOperationThen(t *testing.T) {
	// A synthetic definition where the replace operation itself has a
	// then: entry, to prove Replace routes through the chain executor.
	def := &definitions.Definition{
		Name:   "gomod",
		Binary: "go",
		Commands: map[string]definitions.Command{
			"replace": {
				Base: []string{"mod", "edit"},
				Args: map[string]definitions.Arg{"spec": {Flag: "-replace"}},
				Then: []definitions.Command{{Base: []string{"post"}}},
			},
			"tidy": {Base: []string{"mod", "tidy"}},
		},
		Capabilities: []string{"replace_path"},
	}
	runner := NewMockRunner()
	mgr := newTestManager(def, runner)
	_, err := mgr.Replace(context.Background(), "example.com/x", ReplaceOptions{Path: "../x"})
	if err != nil {
		t.Fatalf("Replace: %v", err)
	}
	// replace + its then: (post) + tidy = 3
	if len(runner.Captured) != 3 {
		t.Fatalf("captured %d commands, want 3: %v", len(runner.Captured), runner.Captured)
	}
	if !slicesEqual(runner.Captured[1], []string{"go", "post"}) {
		t.Errorf("then: command not run: %v", runner.Captured)
	}
}

func TestGenericManager_Path_Raw(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"show", "--path"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   "/usr/local/lib/testpkg/lodash\n",
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "lodash")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}

	if result.Path != "/usr/local/lib/testpkg/lodash" {
		t.Errorf("got path %q, want %q", result.Path, "/usr/local/lib/testpkg/lodash")
	}

	if len(runner.Captured) != 1 {
		t.Fatalf("expected 1 command, got %d", len(runner.Captured))
	}
	expected := []string{"testpkg", "show", "--path", "lodash"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Path_JSON(t *testing.T) {
	def := &definitions.Definition{
		Name:   "gomod",
		Binary: "go",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"list", "-m", "-json"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
				Extract: &definitions.Extract{
					Type:  "json",
					Field: "Dir",
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   `{"Path": "github.com/pkg/errors", "Dir": "/home/user/go/pkg/mod/github.com/pkg/errors@v0.9.1"}`,
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "github.com/pkg/errors")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}

	expected := "/home/user/go/pkg/mod/github.com/pkg/errors@v0.9.1"
	if result.Path != expected {
		t.Errorf("got path %q, want %q", result.Path, expected)
	}
}

func TestGenericManager_Path_LinePrefix(t *testing.T) {
	def := &definitions.Definition{
		Name:   "pip",
		Binary: "pip",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"show"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
				Extract: &definitions.Extract{
					Type:   "line_prefix",
					Prefix: "Location: ",
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout: `Name: requests
Version: 2.28.1
Summary: Python HTTP for Humans.
Location: /usr/local/lib/python3.9/site-packages
Requires: certifi, charset-normalizer`,
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "requests")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}

	expected := "/usr/local/lib/python3.9/site-packages"
	if result.Path != expected {
		t.Errorf("got path %q, want %q", result.Path, expected)
	}
}

func TestGenericManager_Path_PythonDistribution(t *testing.T) {
	def := &definitions.Definition{
		Name:   "pip",
		Binary: "pip",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"show", "-f"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
				Extract: &definitions.Extract{Type: "python_distribution"},
			},
		},
		Capabilities: []string{"path"},
	}
	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout: `Name: requests
Location: /venv/lib/python3.12/site-packages
Files:
  requests-2.32.0.dist-info/licenses/LICENSE
  requests/__init__.py
`,
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "requests")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}
	if result.Path != "/venv/lib/python3.12/site-packages" {
		t.Errorf("path = %q", result.Path)
	}
	wantFiles := []string{
		filepath.Clean("/venv/lib/python3.12/site-packages/requests-2.32.0.dist-info/licenses/LICENSE"),
		filepath.Clean("/venv/lib/python3.12/site-packages/requests/__init__.py"),
	}
	if !slicesEqual(result.Files, wantFiles) {
		t.Errorf("files = %#v, want %#v", result.Files, wantFiles)
	}
	if result.Result != runner.Results[0] {
		t.Error("underlying command result was not retained")
	}
}

func TestGenericManager_Path_Template(t *testing.T) {
	def := &definitions.Definition{
		Name:   "yarn",
		Binary: "yarn",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"why"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true, ExtractionOnly: true},
				},
				Extract: &definitions.Extract{
					Type:    "template",
					Pattern: "node_modules/{package}",
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   "whatever output, ignored for template",
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "lodash")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}

	if result.Path != "node_modules/lodash" {
		t.Errorf("got path %q, want %q", result.Path, "node_modules/lodash")
	}

	// extraction_only means package arg is not passed to command
	expected := []string{"yarn", "why"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Path_JSONArray(t *testing.T) {
	def := &definitions.Definition{
		Name:   "cargo",
		Binary: "cargo",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"metadata", "--format-version", "1"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true, ExtractionOnly: true},
				},
				Extract: &definitions.Extract{
					Type:          "json_array",
					ArrayField:    "packages",
					MatchField:    "name",
					ExtractField:  "manifest_path",
					StripFilename: true,
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout: `{
			"packages": [
				{"name": "serde", "manifest_path": "/home/user/.cargo/registry/src/serde-1.0.0/Cargo.toml"},
				{"name": "tokio", "manifest_path": "/home/user/.cargo/registry/src/tokio-1.0.0/Cargo.toml"}
			]
		}`,
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "serde")
	if err != nil {
		t.Fatalf("Path failed: %v", err)
	}

	expected := "/home/user/.cargo/registry/src/serde-1.0.0"
	if result.Path != expected {
		t.Errorf("got path %q, want %q", result.Path, expected)
	}
}

func TestGenericManager_Path_RunnerError(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"path"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Errors = []error{errors.New("command not found")}

	mgr := newTestManager(def, runner)
	_, err := mgr.Path(context.Background(), "lodash")
	if err == nil {
		t.Error("expected error, got nil")
	}
}

func TestGenericManager_Path_ExtractionError(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"path": {
				Base: []string{"path"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
				},
				Extract: &definitions.Extract{
					Type:   "line_prefix",
					Prefix: "Location: ",
				},
			},
		},
		Capabilities: []string{"path"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   "no location line here",
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Path(context.Background(), "lodash")
	if err == nil {
		t.Error("expected extraction error, got nil")
	}
	// Result should still be returned even on extraction error
	if result == nil || result.Result == nil {
		t.Error("expected result to be returned even on extraction error")
	}
}

func TestGenericManager_Path_NoPathCommand(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"install": {
				Base: []string{"install"},
			},
		},
		Capabilities: []string{"install"},
	}

	runner := NewMockRunner()
	mgr := newTestManager(def, runner)
	_, err := mgr.Path(context.Background(), "lodash")
	if err == nil {
		t.Error("expected error for missing path command, got nil")
	}
}

func TestGenericManager_Vendor(t *testing.T) {
	def := &definitions.Definition{
		Name:   "gomod",
		Binary: "go",
		Commands: map[string]definitions.Command{
			"vendor": {
				Base: []string{"mod", "vendor"},
			},
		},
		Capabilities: []string{"vendor"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   "",
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Vendor(context.Background())
	if err != nil {
		t.Fatalf("Vendor failed: %v", err)
	}

	if result.ExitCode != 0 {
		t.Errorf("got exit code %d, want 0", result.ExitCode)
	}

	if len(runner.Captured) != 1 {
		t.Fatalf("expected 1 command, got %d", len(runner.Captured))
	}
	expected := []string{"go", "mod", "vendor"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Vendor_NoCommand(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"install": {
				Base: []string{"install"},
			},
		},
		Capabilities: []string{"install"},
	}

	runner := NewMockRunner()
	mgr := newTestManager(def, runner)
	_, err := mgr.Vendor(context.Background())
	if err == nil {
		t.Error("expected error for missing vendor command, got nil")
	}
}

func TestGenericManager_Resolve(t *testing.T) {
	def := &definitions.Definition{
		Name:   "npm",
		Binary: "npm",
		Commands: map[string]definitions.Command{
			"resolve": {
				Base:         []string{"ls"},
				DefaultFlags: []string{"--depth", "Infinity", "--json", "--long"},
			},
		},
		Capabilities: []string{"resolve"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   `{"dependencies": {}}`,
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Resolve(context.Background())
	if err != nil {
		t.Fatalf("Resolve failed: %v", err)
	}

	if result.ExitCode != 0 {
		t.Errorf("got exit code %d, want 0", result.ExitCode)
	}

	if len(runner.Captured) != 1 {
		t.Fatalf("expected 1 command, got %d", len(runner.Captured))
	}
	expected := []string{"npm", "ls", "--depth", "Infinity", "--json", "--long"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Resolve_NoCommand(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"install": {
				Base: []string{"install"},
			},
		},
		Capabilities: []string{"install"},
	}

	runner := NewMockRunner()
	mgr := newTestManager(def, runner)
	_, err := mgr.Resolve(context.Background())
	if err == nil {
		t.Error("expected error for missing resolve command, got nil")
	}
}

func TestGenericManager_Resolve_RunnerError(t *testing.T) {
	def := &definitions.Definition{
		Name:   "gomod",
		Binary: "go",
		Commands: map[string]definitions.Command{
			"resolve": {
				Base: []string{"mod", "graph"},
			},
		},
		Capabilities: []string{"resolve"},
	}

	runner := NewMockRunner()
	runner.Errors = []error{errors.New("command not found")}

	mgr := newTestManager(def, runner)
	_, err := mgr.Resolve(context.Background())
	if err == nil {
		t.Error("expected error, got nil")
	}
}

//nolint:dupl // structurally mirrors TestGenericManager_Vendor by design
func TestGenericManager_Init(t *testing.T) {
	def := &definitions.Definition{
		Name:   "npm",
		Binary: "npm",
		Commands: map[string]definitions.Command{
			"init": {
				Base: []string{"init", "-y"},
			},
		},
		Capabilities: []string{"init"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{
		ExitCode: 0,
		Stdout:   "Wrote to /test/project/package.json",
	}}

	mgr := newTestManager(def, runner)
	result, err := mgr.Init(context.Background())
	if err != nil {
		t.Fatalf("Init failed: %v", err)
	}

	if result.ExitCode != 0 {
		t.Errorf("got exit code %d, want 0", result.ExitCode)
	}

	if len(runner.Captured) != 1 {
		t.Fatalf("expected 1 command, got %d", len(runner.Captured))
	}
	expected := []string{"npm", "init", "-y"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Init_NoCommand(t *testing.T) {
	def := &definitions.Definition{
		Name:   "testpkg",
		Binary: "testpkg",
		Commands: map[string]definitions.Command{
			"install": {
				Base: []string{"install"},
			},
		},
		Capabilities: []string{"install"},
	}

	runner := NewMockRunner()
	mgr := newTestManager(def, runner)
	_, err := mgr.Init(context.Background())
	if err == nil {
		t.Error("expected error for missing init command, got nil")
	}
}

func TestGenericManager_Init_RunnerError(t *testing.T) {
	def := &definitions.Definition{
		Name:   "cargo",
		Binary: "cargo",
		Commands: map[string]definitions.Command{
			"init": {
				Base: []string{"init", "--lib"},
			},
		},
		Capabilities: []string{"init"},
	}

	runner := NewMockRunner()
	runner.Errors = []error{errors.New("cargo not found")}

	mgr := newTestManager(def, runner)
	_, err := mgr.Init(context.Background())
	if err == nil {
		t.Error("expected error, got nil")
	}
}

func TestGenericManager_Add_WithVersion(t *testing.T) {
	def := &definitions.Definition{
		Name:   "npm",
		Binary: "npm",
		Commands: map[string]definitions.Command{
			"add": {
				Base: []string{"install"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
					"version": {Position: 0, Suffix: "@", Required: false},
				},
			},
		},
		Capabilities: []string{"add"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{ExitCode: 0}}

	mgr := newTestManager(def, runner)
	_, err := mgr.Add(context.Background(), "lodash", AddOptions{Version: "4.17.21"})
	if err != nil {
		t.Fatalf("Add failed: %v", err)
	}

	expected := []string{"npm", "install", "lodash@4.17.21"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

func TestGenericManager_Add_WithoutVersion(t *testing.T) {
	def := &definitions.Definition{
		Name:   "npm",
		Binary: "npm",
		Commands: map[string]definitions.Command{
			"add": {
				Base: []string{"install"},
				Args: map[string]definitions.Arg{
					"package": {Position: 0, Required: true},
					"version": {Position: 0, Suffix: "@", Required: false},
				},
			},
		},
		Capabilities: []string{"add"},
	}

	runner := NewMockRunner()
	runner.Results = []*Result{{ExitCode: 0}}

	mgr := newTestManager(def, runner)
	_, err := mgr.Add(context.Background(), "lodash", AddOptions{})
	if err != nil {
		t.Fatalf("Add failed: %v", err)
	}

	// Empty version should not produce a trailing @
	expected := []string{"npm", "install", "lodash"}
	if !slicesEqual(runner.Captured[0], expected) {
		t.Errorf("got command %v, want %v", runner.Captured[0], expected)
	}
}

// TestCapabilityOrdering pins the integer values of public Capability constants.
// Inserting a new constant mid-block silently shifts everything after it; this
// test will fail loudly if that happens. New capabilities go at the end.
func TestCapabilityOrdering(t *testing.T) {
	pinned := []struct {
		cap  Capability
		want int
	}{
		{CapInstall, 0},
		{CapInstallFrozen, 1},
		{CapInstallClean, 2},
		{CapAdd, 3},
		{CapAddDev, 4},
		{CapAddOptional, 5},
		{CapRemove, 6},
		{CapUpdate, 7},
		{CapList, 8},
		{CapOutdated, 9},
		{CapAudit, 10},
		{CapWorkspace, 11},
		{CapJSONOutput, 12},
		{CapSBOMCycloneDX, 13},
		{CapSBOMSPDX, 14},
		{CapPath, 15},
		{CapVendor, 16},
		{CapResolve, 17},
		{CapInit, 18},
	}
	for _, p := range pinned {
		if int(p.cap) != p.want {
			t.Errorf("%s = %d, want %d (did someone insert a new constant mid-iota?)", p.cap, int(p.cap), p.want)
		}
	}
}

func slicesEqual(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}