Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

12.3 KB
Raw Blame
package update

import (
	"bytes"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
)

// installFixture is a download folder holding exe (magpie-windows-amd64.exe,
// as the site names it) and the place it installs to, each with its
// version; what Settle asks of the system answers from them.
type installFixture struct {
	downloads, exe, to, profiles string
	versions                     map[string]uint64
	placed                       []string // folders installCLI was asked to put on PATH
	portable                     string
}

func newInstallFixture(t *testing.T) *installFixture {
	t.Helper()
	root := t.TempDir()
	f := &installFixture{
		downloads: filepath.Join(root, "Downloads"),
		to:        filepath.Join(root, "Local", "Programs", "magpie", "magpie.exe"),
		profiles:  filepath.Join(root, "Roaming"),
		versions:  map[string]uint64{},
	}
	f.exe = filepath.Join(f.downloads, "magpie-windows-amd64.exe")
	if err := os.MkdirAll(f.downloads, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(f.exe, []byte("MZ new download"), 0o755); err != nil {
		t.Fatal(err)
	}
	saved := []any{installTarget, downloadFolder, fileVersion, portableData, webViewHome, installCLI}
	t.Cleanup(func() {
		installTarget = saved[0].(func() string)
		downloadFolder = saved[1].(func(string) bool)
		fileVersion = saved[2].(func(string) uint64)
		portableData = saved[3].(func() string)
		webViewHome = saved[4].(func(string) string)
		installCLI = saved[5].(func(string, string) error)
	})
	installTarget = func() string { return f.to }
	downloadFolder = func(dir string) bool { return samePath(dir, f.downloads) }
	fileVersion = func(p string) uint64 {
		for k, v := range f.versions {
			if samePath(k, p) {
				return v
			}
		}
		return 0
	}
	portableData = func() string { return f.portable }
	webViewHome = func(exe string) string { return filepath.Join(f.profiles, filepath.Base(exe)) }
	installCLI = func(exe, dir string) error {
		f.placed = append(f.placed, dir)
		return nil
	}
	return f
}

func (f *installFixture) installed(t *testing.T, b string, version uint64) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(f.to), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(f.to, []byte(b), 0o755); err != nil {
		t.Fatal(err)
	}
	f.versions[f.to] = version
}

func readString(t *testing.T, p string) string {
	t.Helper()
	b, err := os.ReadFile(p)
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}

// Opened from Downloads with nothing installed, the app is copied to the
// user's programs folder as magpie.exe, that folder goes on the PATH, and
// the installed one is what opens. The download itself stays: it is the
// user's file.
func TestSettleInstallsADownload(t *testing.T) {
	f := newInstallFixture(t)
	to, err := settle(f.exe)
	if err != nil {
		t.Fatal(err)
	}
	if to != f.to {
		t.Fatalf("settle opens %q, want the installed %q", to, f.to)
	}
	if got := readString(t, f.to); got != "MZ new download" {
		t.Fatalf("installed copy holds %q", got)
	}
	if got := readString(t, f.exe); got != "MZ new download" {
		t.Fatalf("the download was changed or removed: %q", got)
	}
	if len(f.placed) != 1 || !samePath(f.placed[0], filepath.Dir(f.to)) {
		t.Fatalf("PATH given %v, want the install folder once", f.placed)
	}
	left, _ := filepath.Glob(filepath.Join(filepath.Dir(f.to), ".magpie-install-*"))
	if len(left) != 0 {
		t.Fatalf("staging files left: %v", left)
	}
}

// A copy kept anywhere the user chose, or a portable one, runs where it
// is and installs nothing; so does one run with MAGPIE_NO_INSTALL=1.
func TestSettleLeavesAChosenPlace(t *testing.T) {
	f := newInstallFixture(t)
	tools := filepath.Join(filepath.Dir(f.downloads), "Tools", "magpie-windows-amd64.exe")
	if err := os.MkdirAll(filepath.Dir(tools), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(tools, []byte("MZ"), 0o755); err != nil {
		t.Fatal(err)
	}
	if to, err := settle(tools); to != "" || err != nil {
		t.Fatalf("a copy in a folder of the user's own opens %q (%v)", to, err)
	}
	f.portable = filepath.Join(f.downloads, "data")
	if to, err := settle(f.exe); to != "" || err != nil {
		t.Fatalf("a portable copy opens %q (%v)", to, err)
	}
	f.portable = ""
	if to, err := settle(f.to); to != "" || err != nil {
		t.Fatalf("the installed copy opens %q (%v)", to, err)
	}
	if exists(f.to) {
		t.Fatal("installed though it shouldn't have been")
	}
	t.Setenv(NoInstallEnv, "1")
	if from, to := Settle(); from != "" || to != "" {
		t.Fatalf("MAGPIE_NO_INSTALL=1 still opens %q", to)
	}
	if forwards(f.exe) {
		t.Fatal("MAGPIE_NO_INSTALL=1 still counts as forwarding")
	}
}

// Installed already: the download opens it, and only a newer version goes
// in its place. An older or unknown one leaves the installed copy, which
// updates itself.
func TestSettleKeepsTheInstalledVersion(t *testing.T) {
	for _, c := range []struct {
		name         string
		mine, theirs uint64
		want         string
		placedOnPath bool
	}{
		{"older download", 1<<32 | 100<<16, 1<<32 | 200<<16, "MZ installed", false},
		{"same version", 1<<32 | 200<<16, 1<<32 | 200<<16, "MZ installed", false},
		{"no version in the download", 0, 1<<32 | 200<<16, "MZ installed", false},
		{"no version installed", 1<<32 | 300<<16, 0, "MZ installed", false},
		{"newer download", 1<<32 | 300<<16, 1<<32 | 200<<16, "MZ new download", false},
	} {
		t.Run(c.name, func(t *testing.T) {
			f := newInstallFixture(t)
			f.installed(t, "MZ installed", c.theirs)
			f.versions[f.exe] = c.mine
			to, err := settle(f.exe)
			if err != nil || to != f.to {
				t.Fatalf("settle = %q, %v; want %q", to, err, f.to)
			}
			if got := readString(t, f.to); got != c.want {
				t.Fatalf("installed holds %q, want %q", got, c.want)
			}
			if len(f.placed) != 0 {
				t.Fatalf("PATH written again for an installed magpie: %v", f.placed)
			}
			if got := readString(t, f.exe); got != "MZ new download" {
				t.Fatalf("the download was changed: %q", got)
			}
		})
	}
}

// A failure to install leaves the download running where it is.
func TestSettleFailingRunsOn(t *testing.T) {
	f := newInstallFixture(t)
	// a file where the install folder should be
	if err := os.MkdirAll(filepath.Dir(filepath.Dir(f.to)), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Dir(f.to), []byte("in the way"), 0o644); err != nil {
		t.Fatal(err)
	}
	to, err := settle(f.exe)
	if to != "" || err == nil {
		t.Fatalf("settle = %q, %v; want this one to run on, with the reason", to, err)
	}
	if len(f.placed) != 0 {
		t.Fatal("PATH written for an install that failed")
	}
}

// WebView2 keeps a profile per exe name, so magpie.exe would start with
// none: the installed copy is pointed at the download's, unless it has
// one of its own.
func TestSettleKeepsTheWebViewProfile(t *testing.T) {
	f := newInstallFixture(t)
	old := filepath.Join(f.profiles, "magpie-windows-amd64.exe")
	if err := os.MkdirAll(old, 0o755); err != nil {
		t.Fatal(err)
	}
	if _, err := settle(f.exe); err != nil {
		t.Fatal(err)
	}
	note := filepath.Join(filepath.Dir(f.to), "webview-profile")
	if got := strings.TrimSpace(readString(t, note)); !samePath(got, old) {
		t.Fatalf("webview note names %q, want %q", got, old)
	}

	g := newInstallFixture(t)
	for _, d := range []string{"magpie-windows-amd64.exe", "magpie.exe"} {
		if err := os.MkdirAll(filepath.Join(g.profiles, d), 0o755); err != nil {
			t.Fatal(err)
		}
	}
	if _, err := settle(g.exe); err != nil {
		t.Fatal(err)
	}
	if exists(filepath.Join(filepath.Dir(g.to), "webview-profile")) {
		t.Fatal("pointed away from magpie.exe's own profile")
	}
}

// The installed copy clears what magpie wrote beside the download: the
// magpie.com and magpie.cmd that ran it, and what updates moved aside.
// A magpie.cmd of the user's own, or one magpie wrote for another
// program there, stays.
func TestSettledClearsOnlyMagpiesFiles(t *testing.T) {
	f := newInstallFixture(t)
	dir := f.downloads
	com := filepath.Join(dir, comName)
	if err := os.WriteFile(com, comText([]byte("MZ launcher"), f.exe), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(dir, shimName), []byte(shimText(f.exe)), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(f.exe+".old", []byte("MZ"), 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv(installedFromEnv, f.exe)
	Settled()
	for _, p := range []string{com, filepath.Join(dir, shimName), f.exe + ".old"} {
		if exists(p) {
			t.Fatalf("%s left", filepath.Base(p))
		}
	}
	if !exists(f.exe) {
		t.Fatal("the download itself was removed")
	}
	if os.Getenv(installedFromEnv) != "" {
		t.Fatal("passed on to what the installed magpie starts")
	}

	// the user's own, and magpie's for another program
	own := []byte("@echo off\r\nrem mine\r\n\"%~dp0magpie-windows-amd64.exe\" %*\r\n")
	if err := os.WriteFile(filepath.Join(dir, shimName), own, 0o755); err != nil {
		t.Fatal(err)
	}
	other := comText([]byte("MZ launcher"), filepath.Join(dir, "magpie-windows-amd64 (1).exe"))
	if err := os.WriteFile(com, other, 0o755); err != nil {
		t.Fatal(err)
	}
	t.Setenv(installedFromEnv, f.exe)
	Settled()
	if b, err := os.ReadFile(filepath.Join(dir, shimName)); err != nil || !bytes.Equal(b, own) {
		t.Fatalf("the user's magpie.cmd: %q, %v", b, err)
	}
	if b, err := os.ReadFile(com); err != nil || !bytes.Equal(b, other) {
		t.Fatalf("another program's magpie.com: %v", err)
	}
}

// Forward opens the installed one with this one's arguments, waits for
// its word, and passes that word on to a restart to update waiting on
// this one.
func TestForwardWaitsForTheInstalledOne(t *testing.T) {
	waiting := filepath.Join(t.TempDir(), "started")
	t.Setenv(startedEnv, waiting)
	was := launch
	t.Cleanup(func() { launch = was })
	var gotExe string
	var gotArgs, gotEnv []string
	launch = func(exe string, args, env []string) (<-chan struct{}, func(), error) {
		gotExe, gotArgs, gotEnv = exe, args, env
		for _, e := range env {
			if m, ok := strings.CutPrefix(e, startedEnv+"="); ok {
				os.WriteFile(m, []byte("1"), 0o644)
			}
		}
		return make(chan struct{}), func() {}, nil
	}
	if err := Forward(`C:\Users\u\Downloads\magpie-windows-amd64.exe`, `C:\Users\u\AppData\Local\Programs\magpie\magpie.exe`); err != nil {
		t.Fatal(err)
	}
	if !strings.HasSuffix(gotExe, `magpie.exe`) {
		t.Fatalf("opened %q", gotExe)
	}
	if strings.Join(gotArgs, " ") != strings.Join(os.Args[1:], " ") {
		t.Fatalf("args %v, want %v", gotArgs, os.Args[1:])
	}
	var from, marks int
	for _, e := range gotEnv {
		if strings.HasPrefix(e, installedFromEnv+`=C:\Users\u\Downloads\magpie-windows-amd64.exe`) {
			from++
		}
		if strings.HasPrefix(e, startedEnv+"=") {
			marks++
			if strings.HasSuffix(e, "="+waiting) {
				t.Fatal("the restart's own marker handed on, which it removes as it reads it")
			}
		}
	}
	if from != 1 || marks != 1 {
		t.Fatalf("env: %d %s, %d %s", from, installedFromEnv, marks, startedEnv)
	}
	if !exists(waiting) {
		t.Fatal("the restart waiting on this one was never told")
	}

	// one that quits without a word: this one runs on
	launch = func(string, []string, []string) (<-chan struct{}, func(), error) {
		c := make(chan struct{})
		close(c)
		return c, func() {}, nil
	}
	if err := Forward("a", "b"); err == nil {
		t.Fatal("a magpie that quit unstarted taken as opened")
	}
}

// A download that opens the installed magpie writes no magpie.com beside
// it: the terminal's magpie is the installed one's.
func TestNoCompanionBesideAForwardingDownload(t *testing.T) {
	f := newInstallFixture(t)
	f.installed(t, "MZ installed", 0)
	if forwards(f.exe) != (runtime.GOOS == "windows") {
		// forwards is Windows' alone
		t.Fatalf("forwards(%s) = %v", f.exe, forwards(f.exe))
	}
	was := comLauncher
	t.Cleanup(func() { comLauncher = was })
	comLauncher = []byte("MZ launcher")
	t.Setenv("PATH", f.downloads)
	if err := EnsureCompanion(f.exe); err != nil {
		t.Fatal(err)
	}
	if got := exists(filepath.Join(f.downloads, comName)); got == forwards(f.exe) {
		t.Fatalf("magpie.com beside the download: %v, forwarding: %v", got, forwards(f.exe))
	}
}

func TestInFolder(t *testing.T) {
	root := t.TempDir()
	for _, c := range []struct {
		path string
		want bool
	}{
		{root, true},
		{filepath.Join(root, "Temp1_magpie.zip"), true},
		{strings.ToUpper(filepath.Join(root, "x")), true},
		{filepath.Dir(root), false},
		{root + "-other", false},
	} {
		if got := inFolder(c.path, root); got != c.want {
			t.Errorf("inFolder(%q) = %v, want %v", c.path, got, c.want)
		}
	}
	if inFolder(root, "") || inFolder(root, "relative") {
		t.Error("a folder that isn't absolute holds things")
	}
}