//go:build !integration
package fallbacksync
import (
"encoding/json"
"errors"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/claudehooks"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/opencodeplugin"
"gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
)
func TestUnits_Darwin(t *testing.T) {
t.Parallel()
units, err := Units("darwin", "/home/me", Job{GlabPath: "/opt/homebrew/bin/glab", ConfigDir: "/home/me/.config/glab-cli"})
require.NoError(t, err)
require.Len(t, units, 1)
assert.Equal(t, "/home/me/Library/LaunchAgents/com.gitlab.glab-govern-audit-sync.plist", units[0].Path)
assert.Equal(t, `
Label
com.gitlab.glab-govern-audit-sync
ProgramArguments
/opt/homebrew/bin/glab
minder
audit
sync
--all
--silent
EnvironmentVariables
GLAB_CONFIG_DIR
/home/me/.config/glab-cli
StartInterval
1800
RunAtLoad
`, units[0].Content)
}
func TestUnits_Linux(t *testing.T) {
t.Parallel()
units, err := Units("linux", "/home/me", Job{GlabPath: "/home/me/.local/share/mise/shims/glab", ConfigDir: "/home/me/.config/glab-cli"})
require.NoError(t, err)
require.Len(t, units, 2)
assert.Equal(t, "/home/me/.config/systemd/user/glab-govern-audit-sync.service", units[0].Path)
assert.Equal(t, `[Unit]
Description=GitLab AI agent governance fallback sync
[Service]
Type=oneshot
Environment="GLAB_CONFIG_DIR=/home/me/.config/glab-cli"
ExecStart="/home/me/.local/share/mise/shims/glab" minder audit sync --all --silent
`, units[0].Content)
assert.Equal(t, "/home/me/.config/systemd/user/glab-govern-audit-sync.timer", units[1].Path)
assert.Equal(t, `[Unit]
Description=GitLab AI agent governance fallback sync timer
[Timer]
OnBootSec=5min
OnUnitActiveSec=30min
[Install]
WantedBy=timers.target
`, units[1].Content)
}
func TestUnits_Unsupported(t *testing.T) {
t.Parallel()
_, err := Units("windows", `C:\Users\me`, Job{GlabPath: `C:\glab.exe`})
require.ErrorIs(t, err, ErrUnsupportedOS)
}
func TestInstalledBinary_RoundTrip(t *testing.T) {
t.Parallel()
for _, goos := range []string{"darwin", "linux"} {
t.Run(goos, func(t *testing.T) {
t.Parallel()
home := t.TempDir()
glab := `/odd path/100%/a&b/"q"\x/glab`
units, err := Units(goos, home, Job{GlabPath: glab, ConfigDir: `/cfg/50%/"x"`})
require.NoError(t, err)
for _, u := range units {
require.NoError(t, os.MkdirAll(filepath.Dir(u.Path), 0o755))
require.NoError(t, os.WriteFile(u.Path, []byte(u.Content), 0o644))
}
got, err := InstalledBinary(goos, home)
require.NoError(t, err)
assert.Equal(t, glab, got)
})
}
}
func TestInstalledBinary_NotInstalled(t *testing.T) {
t.Parallel()
_, err := InstalledBinary("linux", t.TempDir())
require.ErrorIs(t, err, ErrNotInstalled)
}
func TestInstallUninstall_Darwin(t *testing.T) {
t.Parallel()
home := t.TempDir()
plist := filepath.Join(home, "Library", "LaunchAgents", "com.gitlab.glab-govern-audit-sync.plist")
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
gomock.InOrder(
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootout", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
Return([]byte("not loaded"), errors.New("exit status 3")),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootstrap", "gui/501", plist}, nil).
Return(nil, nil),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootout", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
Return(nil, nil),
)
require.NoError(t, Install(t.Context(), mExec, "darwin", home, Job{GlabPath: "/usr/local/bin/glab"}, 501))
assert.FileExists(t, plist)
removed, err := Uninstall(t.Context(), mExec, "darwin", home, 501)
require.NoError(t, err)
assert.True(t, removed)
assert.NoFileExists(t, plist)
}
func TestInstallUninstall_Linux(t *testing.T) {
t.Parallel()
home := t.TempDir()
dir := filepath.Join(home, ".config", "systemd", "user")
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
gomock.InOrder(
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
Return(nil, nil),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "enable", "--now", "glab-govern-audit-sync.timer"}, nil).
Return(nil, nil),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "disable", "--now", "glab-govern-audit-sync.timer"}, nil).
Return(nil, nil),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
Return(nil, nil),
)
require.NoError(t, Install(t.Context(), mExec, "linux", home, Job{GlabPath: "/usr/bin/glab"}, 1000))
assert.FileExists(t, filepath.Join(dir, "glab-govern-audit-sync.service"))
assert.FileExists(t, filepath.Join(dir, "glab-govern-audit-sync.timer"))
removed, err := Uninstall(t.Context(), mExec, "linux", home, 1000)
require.NoError(t, err)
assert.True(t, removed)
assert.NoFileExists(t, filepath.Join(dir, "glab-govern-audit-sync.service"))
assert.NoFileExists(t, filepath.Join(dir, "glab-govern-audit-sync.timer"))
}
func TestInstall_LoadFailure(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
Return([]byte("Failed to connect to bus"), errors.New("exit status 1"))
home := t.TempDir()
err := Install(t.Context(), mExec, "linux", home, Job{GlabPath: "/usr/bin/glab"}, 1000)
require.Error(t, err)
assert.Contains(t, err.Error(), "Failed to connect to bus")
_, err = InstalledBinary("linux", home)
require.ErrorIs(t, err, ErrNotInstalled, "a job that could not be loaded is not left installed")
}
func TestUninstall_NothingInstalled(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "disable", "--now", "glab-govern-audit-sync.timer"}, nil).
Return(nil, errors.New("unit not found"))
removed, err := Uninstall(t.Context(), mExec, "linux", t.TempDir(), 1000)
require.NoError(t, err)
assert.False(t, removed)
}
func TestStatus_RoundTrip(t *testing.T) {
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
_, err := ReadStatus()
require.ErrorIs(t, err, ErrNoStatus)
want := Status{
StartedAt: time.Date(2026, 10, 8, 1, 0, 0, 0, time.UTC),
FinishedAt: time.Date(2026, 10, 8, 1, 0, 2, 0, time.UTC),
SessionsSynced: 2,
EventsPosted: 5,
Errors: []string{"session a: boom"},
}
require.NoError(t, WriteStatus(want))
got, err := ReadStatus()
require.NoError(t, err)
assert.Equal(t, want, *got)
}
func TestState_Darwin(t *testing.T) {
t.Parallel()
launchctlPrint := func(t *testing.T, out string, err error) JobState {
t.Helper()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"print", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
Return([]byte(out), err)
state, stateErr := State(t.Context(), mExec, "darwin", 501)
require.NoError(t, stateErr)
return state
}
t.Run("failed run", func(t *testing.T) {
t.Parallel()
state := launchctlPrint(t, "gui/501/com.gitlab.glab-govern-audit-sync = {\n\texit timeout = 5\n\truns = 1\n\tlast exit code = 1\n}\n", nil)
assert.Equal(t, JobState{Loaded: true, Ran: true, ExitCode: 1}, state)
})
t.Run("never run", func(t *testing.T) {
t.Parallel()
state := launchctlPrint(t, "gui/501/com.gitlab.glab-govern-audit-sync = {\n\truns = 0\n\tlast exit code = (never exited)\n}\n", nil)
assert.Equal(t, JobState{Loaded: true}, state)
})
t.Run("not loaded", func(t *testing.T) {
t.Parallel()
state := launchctlPrint(t, "Could not find service \"com.gitlab.glab-govern-audit-sync\" in domain for user gui: 501\n", &exec.ExitError{})
assert.Equal(t, JobState{}, state)
})
t.Run("launchctl does not run", func(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().ExecWithCombinedOutput(gomock.Any(), "launchctl", gomock.Any(), nil).Return(nil, exec.ErrNotFound)
_, err := State(t.Context(), mExec, "darwin", 501)
require.ErrorIs(t, err, exec.ErrNotFound)
})
}
func TestState_Linux(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
gomock.InOrder(
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "is-active", "--quiet", "glab-govern-audit-sync.timer"}, nil).
Return(nil, nil),
mExec.EXPECT().
ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "show", "glab-govern-audit-sync.service", "--property=ExecMainStartTimestampMonotonic,ExecMainStatus"}, nil).
Return([]byte("ExecMainStartTimestampMonotonic=0\nExecMainStatus=0\n"), nil),
)
state, err := State(t.Context(), mExec, "linux", 1000)
require.NoError(t, err)
assert.Equal(t, JobState{Loaded: true}, state, "a start timestamp of 0 means the service has not run since boot")
}
func TestDiscoveredAgents_RoundTrip(t *testing.T) {
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
agents, err := DiscoveredAgents()
require.NoError(t, err)
assert.Empty(t, agents, "no agents are discovered until setup enables them")
require.NoError(t, SetDiscoveredAgents([]string{"codex"}))
agents, err = DiscoveredAgents()
require.NoError(t, err)
assert.Equal(t, []string{"codex"}, agents)
}
func TestHookAgents(t *testing.T) {
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
_, recorded, err := RecordedHookAgents()
require.NoError(t, err)
assert.False(t, recorded, "nothing is recorded before setup chooses")
require.NoError(t, SetHookAgents([]string{}))
agents, recorded, err := RecordedHookAgents()
require.NoError(t, err)
assert.True(t, recorded, "choosing no hook agents is a choice")
assert.Empty(t, agents)
require.NoError(t, SetHookAgents([]string{"opencode"}))
agents, _, err = RecordedHookAgents()
require.NoError(t, err)
assert.Equal(t, []string{"opencode"}, agents)
require.NoError(t, ForgetHookAgents())
_, recorded, err = RecordedHookAgents()
require.NoError(t, err)
assert.False(t, recorded)
require.NoError(t, ForgetHookAgents(), "forgetting twice is fine")
}
func TestAgentSetups_RoundTrip(t *testing.T) {
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
setups, err := ReadAgentSetups()
require.NoError(t, err)
assert.Empty(t, setups, "nothing is recorded before setup")
at := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
want := AgentSetups{"claude-code": {SetUpAt: at}, "codex": {SetUpAt: at, History: true}}
require.NoError(t, SetAgentSetups(want))
setups, err = ReadAgentSetups()
require.NoError(t, err)
assert.Equal(t, want, setups)
}
func TestAgentSetups_Unreadable(t *testing.T) {
dir := t.TempDir()
t.Setenv("GLAB_CONFIG_DIR", dir)
path := filepath.Join(dir, "gaig", "agent-setups.json")
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, []byte("{not json"), 0o600))
_, err := ReadAgentSetups()
require.ErrorContains(t, err, "could not parse "+path)
assert.Contains(t, AgentsReadFix(err), "--uninstall", "uninstalling removes the file")
}
func TestAgentSetups_UploadsFrom(t *testing.T) {
t.Parallel()
at := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
setups := AgentSetups{"claude-code": {SetUpAt: at}, "codex": {SetUpAt: at, History: true}}
tests := map[string]struct {
setups AgentSetups
agent string
want time.Time
}{
"set up": {setups: setups, agent: "claude-code", want: at},
"opted in to history": {setups: setups, agent: "codex"},
"set up before setups were kept": {setups: setups, agent: "cursor"},
"nothing recorded": {agent: "claude-code"},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
t.Parallel()
assert.Equal(t, tc.want, tc.setups.UploadsFrom(tc.agent))
})
}
}
func TestResolvedHookAgents(t *testing.T) {
setup := func(t *testing.T) string {
t.Helper()
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("XDG_CONFIG_HOME", "")
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
return filepath.Join(home, ".claude", "settings.json")
}
installHooks := func(t *testing.T, path string) {
t.Helper()
hooks := map[string][]claudehooks.HookGroup{}
claudehooks.AddHook(hooks, "Stop", claudehooks.StopHookCommand)
hooksJSON, err := claudehooks.MarshalHooks(hooks)
require.NoError(t, err)
require.NoError(t, claudehooks.WriteSettings(path, map[string]json.RawMessage{"hooks": hooksJSON}))
}
t.Run("nothing set up", func(t *testing.T) {
settings := setup(t)
agents, err := ResolvedHookAgents(settings)
require.NoError(t, err)
assert.Empty(t, agents)
})
t.Run("recorded choice", func(t *testing.T) {
settings := setup(t)
installHooks(t, settings)
require.NoError(t, SetHookAgents([]string{"opencode"}))
agents, err := ResolvedHookAgents(settings)
require.NoError(t, err)
assert.Equal(t, []string{"opencode"}, agents, "the recorded choice wins over what is installed")
})
t.Run("older glab: installed hooks and plugin", func(t *testing.T) {
settings := setup(t)
installHooks(t, settings)
plugin, err := opencodeplugin.Path()
require.NoError(t, err)
_, err = opencodeplugin.Install(plugin)
require.NoError(t, err)
agents, err := ResolvedHookAgents(settings)
require.NoError(t, err)
assert.Equal(t, []string{"claude-code", "opencode"}, agents)
})
t.Run("unreadable settings file", func(t *testing.T) {
settings := setup(t)
require.NoError(t, os.MkdirAll(filepath.Dir(settings), 0o755))
require.NoError(t, os.WriteFile(settings, []byte("{not json"), 0o644))
_, err := ResolvedHookAgents(settings)
require.Error(t, err, "an unknown answer must not be recorded as no Claude Code")
})
}
func TestDefaultHookAgents(t *testing.T) {
t.Parallel()
assert.Equal(t, []string{"claude-code"}, DefaultHookAgents(nil, nil), "a first setup syncs Claude Code")
assert.Empty(t, DefaultHookAgents(nil, []string{"codex"}), "Claude Code is not added for someone who only set up Codex")
assert.Equal(t, []string{"opencode"}, DefaultHookAgents([]string{"opencode"}, nil))
}
func TestReadInstalled_Legacy(t *testing.T) {
t.Parallel()
for _, goos := range []string{"darwin", "linux"} {
t.Run(goos, func(t *testing.T) {
t.Parallel()
home := t.TempDir()
units, err := Units(goos, home, Job{GlabPath: "/usr/local/bin/glab", ConfigDir: "/home/me/.config/glab-cli"})
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(units[0].Path), 0o755))
require.NoError(t, os.WriteFile(units[0].Path, []byte(units[0].Content), 0o644))
job, err := ReadInstalled(goos, home)
require.NoError(t, err)
assert.Equal(t, Installed{GlabPath: "/usr/local/bin/glab"}, job)
old := strings.NewReplacer("minder", "govern", `" minder audit sync `, `" govern audit sync `).
Replace(units[0].Content)
require.NotEqual(t, units[0].Content, old)
require.NoError(t, os.WriteFile(units[0].Path, []byte(old), 0o644))
job, err = ReadInstalled(goos, home)
require.NoError(t, err)
assert.Equal(t, Installed{GlabPath: "/usr/local/bin/glab", Legacy: true}, job, "a job from before the rename to glab minder runs glab govern")
})
}
}