Files
skillshare/internal/plugin/service_test.go
T
Willie bcb8c6c781 fix(plugin): skip Agents an update cannot reach instead of blocking it
A plugin installed on several Agents could not be updated anywhere when
one of them could not take the update: a plugin disabled in Codex or
Copilot, or an imported package, blocked the whole plan, so Claude
stayed behind too. These targets are now skipped with the reason, and
the rest update. A skipped update stays pending, where the previous
noop cleared it and left Skillshare believing a stale Agent was current.

Two of those were not real limits: an imported Codex plugin now updates
through `codex plugin marketplace upgrade`, and an imported Pi package
in global mode through `pi update`, which keeps its settings entry.

Skip reasons carry a message key so the dashboard translates them, and
a plugin whose Agents hold different versions shows each instead of
none.

Refs #309
2026-10-01 17:11:20 +08:00

456 lines
16 KiB
Go

package plugin
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"slices"
"strings"
"testing"
)
func fixture(t *testing.T) string {
t.Helper()
root := t.TempDir()
for name, content := range map[string]string{".claude-plugin/plugin.json": `{"name":"demo","version":"1.0.0"}`, ".codex-plugin/plugin.json": `{"name":"demo","version":"1.0.0","skills":"./skills"}`, "skills/demo/SKILL.md": "---\nname: demo\ndescription: Demo\n---\nHello"} {
p := filepath.Join(root, name)
if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(p, []byte(content), 0644); err != nil {
t.Fatal(err)
}
}
return root
}
func TestDiscoverPreservesComponentsAndLeavesOutEscapes(t *testing.T) {
root := fixture(t)
d, err := Discover(context.Background(), root)
if err != nil {
t.Fatal(err)
}
if len(d.Candidates) != 1 || len(d.Candidates[0].Targets) != 5 {
t.Fatalf("unexpected discovery: %+v", d)
}
if err := os.Symlink("/etc/passwd", filepath.Join(root, "escape")); err != nil {
t.Fatal(err)
}
if escaped, err := Discover(context.Background(), root); err != nil || escaped.Digest != d.Digest || len(escaped.Warnings) != 1 {
t.Fatalf("external symlink not left out: %+v %v", escaped, err)
}
}
func TestNativeInventoryStrict(t *testing.T) {
for _, target := range []string{"claude", "codex"} {
if _, err := parseInventory(target, []byte(`{"unexpected":[]}`), ""); err == nil {
t.Fatal("unknown schema accepted")
}
}
items, err := parseInventory("codex", []byte(`{"installed":[{"pluginId":"demo@market","name":"demo","marketplaceName":"market","installed":true,"enabled":false,"version":"1"}],"available":[]}`), "")
if err != nil || len(items) != 1 || items[0].Enabled {
t.Fatalf("%+v %v", items, err)
}
}
func TestClaudeInventoryIgnoresOtherScopesBeforeValidating(t *testing.T) {
data := []byte(`[{"id":"demo@market","scope":"user"},{"id":"(suppressed)@skills-dir","scope":"project","projectPath":"/home/me"}]`)
items, err := parseInventory("claude", data, "")
if err != nil || len(items) != 1 || items[0].ID != "demo@market" {
t.Fatalf("%+v %v", items, err)
}
if _, err := parseInventory("claude", data, "/home/me"); err == nil {
t.Fatal("unsupported identifier in the active project accepted")
}
}
func TestPreviewCancelStaleAndPartialRetry(t *testing.T) {
root := fixture(t)
home := t.TempDir()
config := filepath.Join(home, "config.yaml")
if err := os.WriteFile(config, []byte("# keep me\nmode: merge\n"), 0644); err != nil {
t.Fatal(err)
}
installed := map[string][]Installed{"claude": {}, "codex": {}}
failCodex := true
mutations := 0
runner := func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
joined := strings.Join(args, " ")
if joined == "--version" {
return []byte("test-version"), nil
}
if strings.Contains(joined, "--help") {
return []byte("install add remove uninstall update enable disable --json --scope"), nil
}
if joined == "plugin list --json" {
if bin == "codex" {
return json.Marshal(map[string]any{"installed": installed[bin], "available": []any{}})
}
return json.Marshal(installed[bin])
}
if joined == "plugin marketplace list --json" {
if bin == "codex" {
return []byte(`{"marketplaces":[]}`), nil
}
return []byte(`[]`), nil
}
mutations++
if bin == "codex" && failCodex {
return nil, fmt.Errorf("offline")
}
if len(args) > 2 && (args[1] == "install" || args[1] == "add") {
installed[bin] = append(installed[bin], Installed{ID: args[2], PluginID: args[2], Installed: true, Enabled: true, Scope: "user"})
}
return []byte(`{}`), nil
}
s := &Service{ConfigPath: config, StateDir: filepath.Join(home, "state"), Run: runner}
req := Request{Action: "add", Source: root, Plugin: "demo", Targets: []string{"claude", "codex"}}
p, err := s.Preview(context.Background(), req)
if err != nil {
t.Fatal(err)
}
if mutations != 0 {
t.Fatal("preview mutated native state")
}
if _, err := os.Stat(s.StateDir); !os.IsNotExist(err) {
t.Fatal("preview created state")
}
if err := os.WriteFile(config, []byte("# changed\nmode: merge\n"), 0644); err != nil {
t.Fatal(err)
}
if _, err := s.Apply(context.Background(), req, p.Revision); err == nil {
t.Fatal("stale preview accepted")
}
p, err = s.Preview(context.Background(), req)
if err != nil {
t.Fatal(err)
}
result, err := s.Apply(context.Background(), req, p.Revision)
if err == nil || len(result.Results) != 2 {
t.Fatalf("expected partial result: %+v %v", result, err)
}
failCodex = false
req = Request{Action: "sync"}
p, err = s.Preview(context.Background(), req)
if err != nil {
t.Fatal(err)
}
before := mutations
result, err = s.Apply(context.Background(), req, p.Revision)
if err != nil {
t.Fatal(err)
}
if mutations-before != 2 {
t.Fatalf("retry repeated successful target: %d", mutations-before)
}
data, _ := os.ReadFile(config)
if !strings.Contains(string(data), "# changed") {
t.Fatal("lost user comment")
}
}
func TestProjectCodexNeverFallsBackToGlobal(t *testing.T) {
s := &Service{ConfigPath: filepath.Join(t.TempDir(), "config.yaml"), ProjectRoot: t.TempDir(), StateDir: t.TempDir()}
p, err := s.Preview(context.Background(), Request{Action: "add", Source: fixture(t), Plugin: "demo", Targets: []string{"codex"}})
if err != nil {
t.Fatal(err)
}
if !p.Blocked {
t.Fatal("project Codex install was not blocked")
}
}
func TestSyncSelectionDoesNotToggleNativeEnabledState(t *testing.T) {
dir := t.TempDir()
config := filepath.Join(dir, "config.yaml")
err := os.WriteFile(config, []byte("plugins:\n packages:\n demo:\n bindings:\n codex:\n id: demo@market\n"), 0600)
if err != nil {
t.Fatal(err)
}
installed := true
mutations := []string{}
s := &Service{ConfigPath: config, StateDir: filepath.Join(dir, "state"), Run: func(ctx context.Context, dir string, env []string, target string, args ...string) ([]byte, error) {
joined := strings.Join(args, " ")
if joined == "--version" {
return []byte("0.154.0"), nil
}
if strings.Contains(joined, "--help") {
return []byte("--json"), nil
}
if joined == "plugin list --json" {
if installed {
return []byte(`{"installed":[{"pluginId":"demo@market","installed":true,"enabled":false}],"available":[]}`), nil
}
return []byte(`{"installed":[],"available":[]}`), nil
}
mutations = append(mutations, joined)
if strings.HasPrefix(joined, "plugin remove") {
installed = false
}
if strings.HasPrefix(joined, "plugin add") {
installed = true
}
return []byte(`{}`), nil
}}
apply := func(action string) {
t.Helper()
r := Request{Action: action, Name: "demo", Targets: []string{"codex"}}
p, e := s.Preview(context.Background(), r)
if e != nil {
t.Fatal(e)
}
if _, e = s.Apply(context.Background(), r, p.Revision); e != nil {
t.Fatal(e)
}
}
apply("disable")
if len(mutations) != 0 || !installed {
t.Fatal("deselect changed native installation")
}
apply("sync")
if installed {
t.Fatal("sync did not remove excluded plugin")
}
d, err := s.load()
if err != nil {
t.Fatal(err)
}
b, ok := d.packages["demo"].Bindings["codex"]
if !ok || b.Selected() {
t.Fatal("excluded definition was lost")
}
apply("enable")
if installed {
t.Fatal("select installed immediately")
}
apply("sync")
if !installed {
t.Fatal("sync did not restore installation")
}
if len(mutations) != 2 || strings.Contains(strings.Join(mutations, " "), "enable") {
t.Fatalf("unexpected native mutation: %v", mutations)
}
}
func TestAddWithoutTargetsKeepsPackageForLater(t *testing.T) {
root := fixture(t)
s, installed, mutations := fakeClaude(t)
apply := func(r Request) *Plan {
t.Helper()
p, err := s.Preview(context.Background(), r)
if err != nil {
t.Fatal(err)
}
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
t.Fatal(err)
}
return p
}
writeFile(t, root, ".codex-plugin/plugin.json", `{"name":"demo","version":"1.0.0","skills":"./skills","interface":{"logo":"./logo.png"}}`)
writeFile(t, root, "logo.png", "png")
p := apply(Request{Action: "add", Source: root, Plugin: "demo"})
if len(p.Changes) != 1 || p.Changes[0].Action != "record" || *mutations != 0 {
t.Fatalf("add without targets touched an Agent: %+v %d", p.Changes, *mutations)
}
d, _ := s.load()
if pack, ok := d.packages["demo"]; !ok || pack.Source == "" || len(pack.Bindings) != 0 {
t.Fatalf("package not kept for later: %+v", d.packages)
}
if p.Changes[0].Logo != "data:image/png;base64,cG5n" {
t.Fatalf("preview lost the Codex logo: %q", p.Changes[0].Logo)
}
if d.packages["demo"].Version != "1.0.0" {
t.Fatalf("version not recorded without an Agent: %+v", d.packages["demo"])
}
apply(Request{Action: "add", Name: "demo", Source: root, Plugin: "demo", Targets: []string{"claude"}})
apply(Request{Action: "remove", Name: "demo", Targets: []string{"claude"}})
if d, _ = s.load(); len(*installed) != 0 || d.packages["demo"].Source == "" {
t.Fatalf("removing the last Agent dropped the package: %+v %+v", *installed, d.packages)
}
apply(Request{Action: "remove", Name: "demo"})
if d, _ = s.load(); len(d.packages) != 0 {
t.Fatalf("remove kept the package: %+v", d.packages)
}
}
// fakeClaude answers like a Claude Code CLI with an empty inventory, and counts the calls that change it.
func fakeClaude(t *testing.T) (*Service, *[]Installed, *int) {
home := t.TempDir()
installed := []Installed{}
mutations := 0
s := &Service{ConfigPath: filepath.Join(home, "config.yaml"), StateDir: filepath.Join(home, "state"), Run: func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
joined := strings.Join(args, " ")
switch {
case joined == "--version":
return []byte("test-version"), nil
case strings.Contains(joined, "--help"):
return []byte("install add remove uninstall update enable disable --json --scope"), nil
case joined == "plugin list --json":
return json.Marshal(installed)
case joined == "plugin marketplace list --json":
return []byte(`[]`), nil
}
mutations++
if len(args) > 2 && args[1] == "install" {
installed = append(installed, Installed{ID: args[2], PluginID: args[2], Installed: true, Enabled: true, Scope: "user"})
}
if len(args) > 2 && args[1] == "uninstall" {
installed = []Installed{}
}
return []byte(`{}`), nil
}}
return s, &installed, &mutations
}
func TestCheckReportsTheSourceVersion(t *testing.T) {
root := fixture(t)
s, _, _ := fakeClaude(t)
r := Request{Action: "add", Source: root, Plugin: "demo", Targets: []string{"claude"}}
p, err := s.Preview(context.Background(), r)
if err != nil {
t.Fatal(err)
}
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(root, ".claude-plugin/plugin.json"), []byte(`{"name":"demo","version":"1.1.0"}`), 0644); err != nil {
t.Fatal(err)
}
p, err = s.Preview(context.Background(), Request{Action: "check"})
if err != nil || len(p.Changes) != 1 || p.Changes[0].Action != "update-available" || p.Changes[0].Binding.Version != "1.1.0" {
t.Fatalf("check did not report the new version: %+v %v", p, err)
}
}
func TestRecordedSourceDoesNotBlockAnotherDistribution(t *testing.T) {
s, _, _ := fakeClaude(t)
r := Request{Action: "add", Source: fixture(t), Plugin: "demo"}
p, err := s.Preview(context.Background(), r)
if err != nil {
t.Fatal(err)
}
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
t.Fatal(err)
}
p, err = s.Preview(context.Background(), Request{Action: "add", Source: fixture(t), Plugin: "demo", Name: "demo", Targets: []string{"claude"}})
if err != nil || p.Blocked {
t.Fatalf("another source for one Agent was blocked: %+v %v", p, err)
}
}
// fakeAgents installs plugins like Claude and Codex: installing or updating puts the
// marketplace's current version in place, and Codex's add always enables the plugin.
type fakeAgents struct {
version string
installed map[string][]Installed
commands []string
}
func (f *fakeAgents) service(t *testing.T) *Service {
t.Helper()
home := t.TempDir()
t.Setenv("HOME", home)
if f.installed == nil {
f.installed = map[string][]Installed{}
}
s := &Service{ConfigPath: filepath.Join(home, "config.yaml"), StateDir: filepath.Join(home, "state")}
s.Run = func(_ context.Context, _ string, _ []string, bin string, args ...string) ([]byte, error) {
command := strings.Join(args, " ")
switch {
case command == "--version":
return []byte("test"), nil
case strings.Contains(command, "--help"):
return []byte("--json --scope upgrade"), nil
case command == "plugin list --json" && bin == "codex":
return json.Marshal(map[string]any{"installed": f.installed[bin], "available": []any{}})
case command == "plugin list --json":
return json.Marshal(append([]Installed{}, f.installed[bin]...))
case command == "plugin marketplace list --json" && bin == "codex":
return []byte(`{"marketplaces":[]}`), nil
case command == "plugin marketplace list --json":
return []byte(`[]`), nil
}
f.commands = append(f.commands, bin+" "+command)
if args[1] == "add" || args[1] == "install" || args[1] == "update" {
f.installed[bin] = []Installed{{ID: args[2], PluginID: args[2], Installed: true, Enabled: true, Version: f.version, Scope: "user"}}
}
return []byte(`{}`), nil
}
return s
}
// bumpDemo releases version 2.0.0 of the fixture's plugin.
func bumpDemo(t *testing.T, source string, agents *fakeAgents) {
t.Helper()
writeFile(t, source, ".claude-plugin/plugin.json", `{"name":"demo","version":"2.0.0"}`)
writeFile(t, source, ".codex-plugin/plugin.json", `{"name":"demo","version":"2.0.0","skills":"./skills"}`)
agents.version, agents.commands = "2.0.0", nil
}
// Codex has no update command, so an update adds the plugin again from the new snapshot.
func TestCodexUpdateAddsThePluginAgain(t *testing.T) {
agents := &fakeAgents{version: "1.0.0"}
s := agents.service(t)
source := fixture(t)
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"codex"}})
bumpDemo(t, source, agents)
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"codex"}})
if len(agents.commands) != 1 || !strings.HasPrefix(agents.commands[0], "codex plugin add demo@") {
t.Fatalf("commands: %q", agents.commands)
}
}
// Adding would turn a plugin disabled in Codex back on, so the update skips it, and the
// other Agents of the plugin are still updated.
func TestCodexUpdateSkipsADisabledPlugin(t *testing.T) {
agents := &fakeAgents{version: "1.0.0"}
s := agents.service(t)
source := fixture(t)
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"claude", "codex"}})
agents.installed["codex"][0].Enabled = false
bumpDemo(t, source, agents)
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude", "codex"}})
if slices.ContainsFunc(agents.commands, func(c string) bool { return strings.HasPrefix(c, "codex ") }) || !slices.Contains(agents.commands, "claude plugin update "+agents.installed["claude"][0].ID+" --scope user --json") {
t.Fatalf("commands: %q", agents.commands)
}
}
// An imported plugin has no reviewed source; Codex upgrades it with its marketplace.
func TestCodexUpdateOfAnImportUpgradesItsMarketplace(t *testing.T) {
agents := &fakeAgents{installed: map[string][]Installed{"codex": {{PluginID: "demo@team", Installed: true, Enabled: true, Version: "1.0.0"}}}}
s := agents.service(t)
applyPluginRequest(t, s, Request{Action: "import", From: "codex", Plugin: "demo@team"})
agents.commands = nil
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"codex"}})
if !slices.Equal(agents.commands, []string{"codex plugin marketplace upgrade team"}) {
t.Fatalf("commands: %q", agents.commands)
}
}
// A skipped update stays pending, so a later sync still knows the plugin is behind.
func TestSkippedUpdateStaysPending(t *testing.T) {
agents := &fakeAgents{version: "1.0.0"}
s := agents.service(t)
source := fixture(t)
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"codex"}})
cfg, err := s.load()
if err != nil {
t.Fatal(err)
}
pack := cfg.packages["demo"]
b := pack.Bindings["codex"]
b.Pending = "update"
pack.Bindings["codex"] = b
cfg.packages["demo"] = pack
if err := s.save(cfg); err != nil {
t.Fatal(err)
}
agents.installed["codex"][0].Enabled = false
applyPluginRequest(t, s, Request{Action: "sync"})
if cfg, _ = s.load(); cfg.packages["demo"].Bindings["codex"].Pending != "update" {
t.Fatalf("pending cleared: %+v", cfg.packages["demo"].Bindings["codex"])
}
}