Files
skillshare/internal/server/handler_git_test.go
T
Willie dd6991ca3c fix(push): refuse unpushed config.yaml history at root scope (#366) (#372)
* fix(push): reject unpushed config history at root scope

Untracking config.yaml at the tip still uploads its contents from earlier local commits. Refuse root-scope pushes before mutation and before upload when unpublished history adds or changes the file or its directory tree, without rewriting history.

Share the check across the CLI and dashboard, return unpushed_config_history, and allow removals and config inherited unchanged from upstream merges. Cover first pushes, dry runs, push --pull, directory paths, renames, and merge commits, and document manual repair in all website locales.

Fixes #366

* fix(push): check exactly what push sends for config history

Review of the config history guard found two range problems:

- The guard checked @{u}..HEAD, but a same-named upstream was pushed with
  a bare `git push`. With remote.pushDefault or push.default=matching that
  could send config-bearing commits to another remote, or other branches,
  that the guard never looked at. PushArgs now always names the upstream
  remote and branch (read from branch config, so names with "/" survive),
  so the checked range and the pushed range are the same.
- Without an upstream every commit on HEAD counted as unpushed, so a
  config.yaml already published on origin followed by the
  "Keep config.yaml out of version control" commit was refused. The guard
  now checks HEAD --not --remotes=<push remote>.

The refusal message now suggests rebasing from just before the oldest
offending commit instead of @{u} or --root, which would rewrite commits
the remote already has.

* fix(push): check config history against the remote's live refs

Local remote-tracking refs can be stale. When another machine force-pushes
the remote to drop a leaked config.yaml commit, this clone's
refs/remotes/<remote>/... still contains it, so the guard treated the leak
as already published and HEAD:main, still a fast-forward, would publish it
again.

The guard now excludes only the objects the push remote's refs point to
right now (git ls-remote), limited to objects this clone has. It falls back
to local remote-tracking refs only when the remote cannot be reached, in
which case the push fails anyway. Revisions go to git log on stdin as
"^<id>" lines because git before 2.42 rejects "--not" there.

* fix(push): screen config history against every push URL, without replace refs

Two more ways the screened history could differ from what git push uploads:

- `git ls-remote <remote>` queries the fetch URL, but git push sends to every
  remote.<name>.pushurl. A commit already on the fetch URL could still be
  new to a push URL. The guard now lists `git remote get-url --push --all`
  and excludes only objects that every push URL has.
- With a refs/replace/* entry for an offending commit, git log read the
  sanitized replacement while the push pack carries the original. The log
  and the rebase-base lookup now run with --no-replace-objects.

* fix(push): let pushes the remote will reject reach the pull step

Our own review of the config history guard found two problems:

- When another machine had pushed, the remote's tip was unknown locally, so
  no live ref survived the "objects this clone has" filter and the whole
  history counted as unpushed. A config.yaml published long ago, followed by
  the stop-tracking commit, then blocked `push --pull` before it could pull,
  and replaced the plain push's ErrPushRejected hint. A push URL whose
  destination branch tip this clone lacks rejects the push as
  non-fast-forward and receives nothing, so it is now left out, and the
  check passes when every push URL is like that. `push --pull` re-runs the
  check after pulling, with the tip known.
- PushRemote read branch.<b>.remote even when @{u} no longer resolved, while
  PushArgs then pushed to origin. pushTarget now follows the same
  HasUpstream rule as PushArgs.
2026-10-04 03:09:17 +08:00

789 lines
29 KiB
Go

package server
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"skillshare/internal/config"
"skillshare/internal/testutil"
)
// setServerGitRoot rewrites the test server's config file with a given git_root
// scope. The auto-reload middleware reloads config from disk on every /api/*
// request, so persisting to the file (not mutating s.cfg) is what the handlers
// actually see. src is the skills source preserved from newTestServer.
func setServerGitRoot(t *testing.T, scope, src string) {
t.Helper()
content := "git_root: " + scope + "\nsource: " + src + "\nmode: merge\ntargets: {}\n"
if err := os.WriteFile(config.ConfigPath(), []byte(content), 0o644); err != nil {
t.Fatal(err)
}
}
func TestHandleGitCommit_NoRemote_CreatesLocalCommit(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
addSkill(t, src, "local-skill")
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{"message":"local checkpoint"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp pushResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if !resp.Success {
t.Fatalf("expected success response: %+v", resp)
}
message := testutil.RunGit(t, src, "log", "-1", "--pretty=%s")
if message != "local checkpoint" {
t.Fatalf("commit message = %q, want %q", message, "local checkpoint")
}
status := testutil.RunGit(t, src, "status", "--porcelain")
if status != "" {
t.Fatalf("expected clean working tree, got %q", status)
}
}
func TestHandleGitCommit_DryRun_DoesNotCreateCommit(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
addSkill(t, src, "dry-run-skill")
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{"message":"dry run checkpoint","dryRun":true}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
count := testutil.RunGit(t, src, "rev-list", "--count", "HEAD")
if count != "1" {
t.Fatalf("commit count = %q, want 1", count)
}
}
func TestHandleGitCommit_NoChanges(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp pushResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Message != "nothing to commit (working tree clean)" {
t.Fatalf("message = %q, want nothing to commit", resp.Message)
}
}
func initServerGitRepo(t *testing.T, dir string) {
t.Helper()
testutil.RunGit(t, dir, "init")
testutil.ConfigureGitUser(t, dir)
testutil.RunGit(t, dir, "commit", "--allow-empty", "-m", "initial")
}
func addFailingOriginRemote(t *testing.T, dir string) {
t.Helper()
missingRemote := "file://" + filepath.Join(t.TempDir(), "missing.git")
testutil.RunGit(t, dir, "remote", "add", "origin", missingRemote)
}
func TestHandleGitBranches_FetchFailureReturnsError(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
addFailingOriginRemote(t, src)
req := httptest.NewRequest(http.MethodGet, "/api/git/branches?fetch=true", nil)
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusInternalServerError {
t.Fatalf("expected 500, got %d: %s", rr.Code, rr.Body.String())
}
if !strings.Contains(rr.Body.String(), "git fetch failed") {
t.Fatalf("response %q does not mention fetch failure", rr.Body.String())
}
}
func TestHandleGitCheckout_FetchFailureStopsCheckout(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
base := testutil.RunGit(t, src, "branch", "--show-current")
testutil.RunGit(t, src, "checkout", "-b", "feature")
testutil.RunGit(t, src, "checkout", base)
addFailingOriginRemote(t, src)
req := httptest.NewRequest(http.MethodPost, "/api/git/checkout", strings.NewReader(`{"branch":"feature"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusInternalServerError {
t.Fatalf("expected 500, got %d: %s", rr.Code, rr.Body.String())
}
if !strings.Contains(rr.Body.String(), "git fetch failed") {
t.Fatalf("response %q does not mention fetch failure", rr.Body.String())
}
if current := testutil.RunGit(t, src, "branch", "--show-current"); current != base {
t.Fatalf("current branch = %q, want %q", current, base)
}
}
// POST /api/git/root with a non-default scope initializes a repo at that scope
// directory and persists git_root to config.
func TestHandleSetGitRoot_SwitchToAgents_InitsAndPersists(t *testing.T) {
s, _ := newTestServer(t)
req := httptest.NewRequest(http.MethodPost, "/api/git/root", strings.NewReader(`{"scope":"agents"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp map[string]any
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if resp["scope"] != "agents" {
t.Fatalf("scope = %v, want agents", resp["scope"])
}
dir, _ := resp["gitRoot"].(string)
if dir == "" {
t.Fatalf("missing gitRoot in response: %+v", resp)
}
if _, err := os.Stat(filepath.Join(dir, ".git")); err != nil {
t.Errorf("expected .git initialized at agents scope %s: %v", dir, err)
}
if s.cfg.GitRoot != "agents" {
t.Errorf("cfg.GitRoot = %q, want agents (persisted)", s.cfg.GitRoot)
}
}
// POST /api/git/root with a remoteURL initializes the scope repo and wires the
// "origin" remote on it in one request (UI parity with the CLI's
// `init --git-root <scope> --remote <url>`).
func TestHandleSetGitRoot_WithRemote_WiresOrigin(t *testing.T) {
s, _ := newTestServer(t)
const remote = "https://example.com/skills.git"
body := `{"scope":"agents","remoteURL":"` + remote + `"}`
req := httptest.NewRequest(http.MethodPost, "/api/git/root", strings.NewReader(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp map[string]any
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
dir, _ := resp["gitRoot"].(string)
if dir == "" {
t.Fatalf("missing gitRoot in response: %+v", resp)
}
got := testutil.RunGit(t, dir, "remote", "get-url", "origin")
if got != remote {
t.Errorf("origin = %q, want %q", got, remote)
}
}
// POST /api/git/root rejects unknown or empty scopes with 400.
func TestHandleSetGitRoot_InvalidScope_Rejected(t *testing.T) {
s, _ := newTestServer(t)
for _, scope := range []string{`"bogus"`, `""`} {
req := httptest.NewRequest(http.MethodPost, "/api/git/root", strings.NewReader(`{"scope":`+scope+`}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Errorf("scope %s: expected 400, got %d: %s", scope, rr.Code, rr.Body.String())
}
}
}
// git_root is global-only; project mode must reject the request.
func TestHandleSetGitRoot_ProjectMode_Rejected(t *testing.T) {
s, _ := newProjectTargetServer(t, nil)
req := httptest.NewRequest(http.MethodPost, "/api/git/root", strings.NewReader(`{"scope":"root"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Fatalf("expected 400 in project mode, got %d: %s", rr.Code, rr.Body.String())
}
}
// GET /api/git/status reports a scope mismatch when the configured root has no
// repo but a sibling scope directory does.
func TestHandleGitStatus_ScopeMismatch(t *testing.T) {
s, _ := newTestServer(t)
// git_root defaults to skills (the source). Plant a stray repo at the agents
// scope dir so the configured root lacks .git but agents has one.
agentsDir := s.cfg.EffectiveAgentsSource()
if err := os.MkdirAll(filepath.Join(agentsDir, ".git"), 0o755); err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodGet, "/api/git/status", nil)
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp gitStatusResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v", err)
}
if !resp.ScopeMismatch {
t.Fatalf("expected scopeMismatch=true, got: %+v", resp)
}
if resp.MismatchScope != "agents" {
t.Errorf("mismatchScope = %q, want agents", resp.MismatchScope)
}
if resp.MismatchDir != agentsDir {
t.Errorf("mismatchDir = %q, want %q", resp.MismatchDir, agentsDir)
}
}
// An invalid (hand-edited) git_root must not silently fall back to the skills
// scope — git operations reject it with a 400, mirroring the CLI's resolveGitRoot.
func TestHandleGitCommit_InvalidGitRoot_Rejected(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
setServerGitRoot(t, "agnets", src) // typo for "agents" — not a valid scope
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{"message":"x"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Fatalf("expected 400 for invalid git_root, got %d: %s", rr.Code, rr.Body.String())
}
if !strings.Contains(rr.Body.String(), "invalid git_root") {
t.Errorf("expected 'invalid git_root' in error, got: %s", rr.Body.String())
}
}
// A nested git repo at the root scope blocks commit with a 400 — committing it
// would record an empty submodule and silently drop its files.
func TestHandleGitCommit_NestedRepo_Blocked(t *testing.T) {
s, src := newTestServer(t)
setServerGitRoot(t, "root", src)
base := config.BaseDir() // root scope operates on BaseDir
if err := os.MkdirAll(base, 0o755); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, base)
if err := os.MkdirAll(filepath.Join(base, "vendored", ".git"), 0o755); err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{"message":"x"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Fatalf("expected 400 nested-repo block, got %d: %s", rr.Code, rr.Body.String())
}
if !strings.Contains(rr.Body.String(), "nested git repositories") {
t.Errorf("expected nested-repo error, got: %s", rr.Body.String())
}
}
// A root-scope dry-run must be strictly read-only — it must not untrack
// config.yaml (no `git rm --cached`). Regression for the guard mutating the
// repo before the dry-run branch.
func TestHandleGitCommit_DryRun_DoesNotUntrackConfig(t *testing.T) {
s, src := newTestServer(t)
setServerGitRoot(t, "root", src)
base := config.BaseDir() // root scope operates on BaseDir
if err := os.MkdirAll(base, 0o755); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, base, "init")
testutil.ConfigureGitUser(t, base)
// A repo that (wrongly) tracks config.yaml: the real run would untrack it,
// but a dry-run must leave it alone.
if err := os.WriteFile(filepath.Join(base, "config.yaml"), []byte("x: 1\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, base, "add", "config.yaml")
testutil.RunGit(t, base, "commit", "-m", "initial with config")
// A stageable change so the request reaches the dry-run branch.
if err := os.WriteFile(filepath.Join(base, "note.md"), []byte("# n\n"), 0o644); err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodPost, "/api/git/commit", strings.NewReader(`{"message":"x","dryRun":true}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
tracked := testutil.RunGit(t, base, "ls-files", "--", "config.yaml")
if !strings.Contains(tracked, "config.yaml") {
t.Error("dry-run must not untrack config.yaml, but it is no longer tracked")
}
}
func TestHandlePush_CleanTreePushesUnpushedCommits(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
req := httptest.NewRequest(http.MethodPost, "/api/push", strings.NewReader(`{}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
branch := testutil.RunGit(t, src, "rev-parse", "--abbrev-ref", "HEAD")
if got, want := testutil.RunGit(t, remote, "rev-parse", branch), testutil.RunGit(t, src, "rev-parse", "HEAD"); got != want {
t.Fatalf("remote %s = %s, want local HEAD %s", branch, got, want)
}
}
func TestHandlePush_RefusesUnpushedConfigHistory(t *testing.T) {
for _, upstream := range []bool{true, false} {
for _, body := range []string{`{}`, `{"dryRun":true}`} {
t.Run(fmt.Sprintf("upstream=%t/%s", upstream, body), func(t *testing.T) {
s, src := newTestServer(t)
setServerGitRoot(t, "root", src)
base := config.BaseDir()
if err := os.MkdirAll(base, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(base, "config.yaml"), []byte("local: config\n"), 0o644); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, base)
if err := os.WriteFile(filepath.Join(base, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, base, "add", ".gitignore")
testutil.RunGit(t, base, "commit", "-m", "ignore config")
remote := testutil.SetupBareRemoteRepo(t, t.TempDir())
testutil.RunGit(t, base, "remote", "add", "origin", remote)
if upstream {
testutil.RunGit(t, base, "push", "-u", "origin", "HEAD")
}
testutil.RunGit(t, base, "add", "-f", "config.yaml")
testutil.RunGit(t, base, "commit", "-m", "oops")
head := testutil.RunGit(t, base, "rev-parse", "HEAD")
badCommit := testutil.RunGit(t, base, "rev-parse", "--short", "HEAD")
status := testutil.RunGit(t, base, "status", "--porcelain")
refs := testutil.RunGit(t, remote, "for-each-ref", "--format=%(refname) %(objectname)")
req := httptest.NewRequest(http.MethodPost, "/api/push", strings.NewReader(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusConflict {
t.Fatalf("expected 409, got %d: %s", rr.Code, rr.Body.String())
}
var resp struct {
Code string `json:"error_code"`
Error string `json:"error"`
}
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatal(err)
}
if resp.Code != "unpushed_config_history" || !strings.Contains(resp.Error, badCommit) || !strings.Contains(resp.Error, "git rebase -i") {
t.Errorf("missing stable code, commit, or remediation: %s", rr.Body.String())
}
if got := testutil.RunGit(t, base, "rev-parse", "HEAD"); got != head {
t.Errorf("refused push changed HEAD: %s -> %s", head, got)
}
if got := testutil.RunGit(t, base, "status", "--porcelain"); got != status {
t.Errorf("refused push changed status: %q -> %q", status, got)
}
if got := testutil.RunGit(t, remote, "for-each-ref", "--format=%(refname) %(objectname)"); got != refs {
t.Errorf("refused push changed remote refs: %q -> %q", refs, got)
}
if got := testutil.RunGit(t, remote, "log", "--all", "--format=%h", "--", "config.yaml"); got != "" {
t.Errorf("remote received config.yaml history: %s", got)
}
})
}
}
}
func TestHandlePull_ReportsPulledCommits(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
testutil.RunGit(t, src, "push", "-u", "origin", "HEAD")
other := filepath.Join(t.TempDir(), "other")
testutil.RunGit(t, "", "clone", remote, other)
testutil.ConfigureGitUser(t, other)
addSkill(t, other, "remote-skill")
testutil.RunGit(t, other, "add", "-A")
testutil.RunGit(t, other, "commit", "-m", "add remote skill")
testutil.RunGit(t, other, "push", "origin", "HEAD")
req := httptest.NewRequest(http.MethodPost, "/api/pull", strings.NewReader(`{}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp struct {
Commits []map[string]string `json:"commits"`
}
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if len(resp.Commits) != 1 || resp.Commits[0]["message"] != "add remote skill" {
t.Fatalf("expected the pulled commit with lowercase JSON keys, got %s", rr.Body.String())
}
}
// pushRemoteFile commits a file from a separate clone of remote, as another machine would.
func pushRemoteFile(t *testing.T, remote, rel, content string) {
t.Helper()
other := filepath.Join(t.TempDir(), "other")
testutil.RunGit(t, "", "clone", remote, other)
testutil.ConfigureGitUser(t, other)
if err := os.MkdirAll(filepath.Dir(filepath.Join(other, rel)), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(other, rel), []byte(content), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, other, "add", "-A")
testutil.RunGit(t, other, "commit", "-m", "add "+rel)
testutil.RunGit(t, other, "push", "origin", "HEAD")
}
func postPull(s *Server, body string) *httptest.ResponseRecorder {
req := httptest.NewRequest(http.MethodPost, "/api/pull", strings.NewReader(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
return rr
}
func TestHandleGitStatus_ReportsBehindAfterFetch(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
testutil.RunGit(t, src, "push", "-u", "origin", "HEAD")
pushRemoteFile(t, remote, "remote-skill/SKILL.md", "# remote\n")
testutil.RunGit(t, src, "fetch")
req := httptest.NewRequest(http.MethodGet, "/api/git/status", nil)
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
var resp struct {
Behind int `json:"behind"`
}
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode: %v (%s)", err, rr.Body.String())
}
if resp.Behind != 1 {
t.Fatalf("expected behind=1, got %d: %s", resp.Behind, rr.Body.String())
}
}
func TestHandlePush_RemoteAheadReportsPushRejected(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
testutil.RunGit(t, src, "push", "-u", "origin", "HEAD")
pushRemoteFile(t, remote, "remote-skill/SKILL.md", "# remote\n")
addSkill(t, src, "local-skill")
req := httptest.NewRequest(http.MethodPost, "/api/push", strings.NewReader(`{}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusConflict || !strings.Contains(rr.Body.String(), `"push_rejected"`) {
t.Fatalf("expected 409 push_rejected, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandlePull_PermissionDeniedLeavesTreeCleanAndNamesPath(t *testing.T) {
if os.Getuid() == 0 {
t.Skip("test requires non-root user")
}
s, src := newTestServer(t)
initServerGitRepo(t, src)
addSkill(t, src, "skillshare")
testutil.RunGit(t, src, "add", "-A")
testutil.RunGit(t, src, "commit", "-m", "add skillshare")
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
testutil.RunGit(t, src, "push", "-u", "origin", "HEAD")
pushRemoteFile(t, remote, ".metadata.json", "{}\n")
pushRemoteFile(t, remote, "skillshare/SKILL.md", "# newer\n")
// As left by a sudo upgrade: this user can no longer replace files here.
locked := filepath.Join(src, "skillshare")
if err := os.Chmod(locked, 0o555); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.Chmod(locked, 0o755) })
rr := postPull(s, `{}`)
if !strings.Contains(rr.Body.String(), `"permission_denied"`) || !strings.Contains(rr.Body.String(), src) {
t.Fatalf("expected permission_denied naming %s, got %d: %s", src, rr.Code, rr.Body.String())
}
if status := testutil.RunGit(t, src, "status", "--porcelain", "-uall"); status != "" {
t.Fatalf("expected no pull residue to block the next pull, got:\n%s", status)
}
}
func TestHandlePull_FirstPullConflictCanBeForced(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
addSkill(t, src, "shared")
testutil.RunGit(t, src, "add", "-A")
testutil.RunGit(t, src, "commit", "-m", "local skill")
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
pushRemoteFile(t, remote, "shared/SKILL.md", "# remote version\n")
testutil.RunGit(t, src, "remote", "add", "origin", remote)
if rr := postPull(s, `{}`); rr.Code != http.StatusConflict || !strings.Contains(rr.Body.String(), `"merge_failed"`) {
t.Fatalf("expected 409 merge_failed, got %d: %s", rr.Code, rr.Body.String())
}
if rr := postPull(s, `{"force":true}`); rr.Code != http.StatusOK {
t.Fatalf("expected force pull to succeed, got %d: %s", rr.Code, rr.Body.String())
}
if got, _ := os.ReadFile(filepath.Join(src, "shared", "SKILL.md")); string(got) != "# remote version\n" {
t.Fatalf("expected the remote file after force pull, got %q", got)
}
}
func TestHandlePull_RootScopeRemoteTracksConfig_Refused(t *testing.T) {
s, src := newTestServer(t)
setServerGitRoot(t, "root", src)
base := config.BaseDir()
if err := os.MkdirAll(base, 0o755); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, base)
if err := os.WriteFile(filepath.Join(base, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, base, "add", ".gitignore")
testutil.RunGit(t, base, "commit", "-m", "scaffold")
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
pushRemoteFile(t, remote, "config.yaml", "sources: {}\n")
pushRemoteFile(t, remote, "skills/test/SKILL.md", "# test\n")
testutil.RunGit(t, base, "remote", "add", "origin", remote)
rr := postPull(s, `{}`)
if rr.Code != http.StatusBadRequest || !strings.Contains(rr.Body.String(), `"remote_tracks_config"`) {
t.Fatalf("expected 400 remote_tracks_config, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandlePull_ExtrasScopeSyncsExtras(t *testing.T) {
s, src := newTestServer(t)
extrasDir := filepath.Join(filepath.Dir(src), "extras")
targetDir := t.TempDir()
cfg := "git_root: extras\nsource: " + src + "\nmode: merge\ntargets: {}\nextras:\n - name: rules\n targets:\n - path: " + targetDir + "\n"
if err := os.WriteFile(config.ConfigPath(), []byte(cfg), 0o644); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(extrasDir, 0o755); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, extrasDir)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, extrasDir, "remote", "add", "origin", remote)
testutil.RunGit(t, extrasDir, "push", "-u", "origin", "HEAD")
pushRemoteFile(t, remote, "rules/team.md", "# team rule\n")
if rr := postPull(s, `{}`); rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if _, err := os.Lstat(filepath.Join(targetDir, "team.md")); err != nil {
t.Fatalf("expected the pulled extra synced to its target: %v", err)
}
}
// setupExtrasScopePull makes an extras-scope repo tracking a bare remote, with
// one extra named "rules" synced to the returned target directory.
func setupExtrasScopePull(t *testing.T) (s *Server, extrasDir, remote, targetDir string) {
t.Helper()
s, src := newTestServer(t)
extrasDir = filepath.Join(filepath.Dir(src), "extras")
targetDir = t.TempDir()
cfg := "git_root: extras\nsource: " + src + "\nmode: merge\ntargets: {}\nextras:\n - name: rules\n targets:\n - path: " + targetDir + "\n"
if err := os.WriteFile(config.ConfigPath(), []byte(cfg), 0o644); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(extrasDir, 0o755); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, extrasDir)
remote = filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, extrasDir, "remote", "add", "origin", remote)
testutil.RunGit(t, extrasDir, "push", "-u", "origin", "HEAD")
return s, extrasDir, remote, targetDir
}
func TestHandlePull_AlwaysSyncSyncsWhenUpToDate(t *testing.T) {
s, extrasDir, _, targetDir := setupExtrasScopePull(t)
if err := os.MkdirAll(filepath.Join(extrasDir, "rules"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(extrasDir, "rules", "local.md"), []byte("# local rule\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, extrasDir, "add", "-A")
testutil.RunGit(t, extrasDir, "commit", "-m", "local rule")
if rr := postPull(s, `{"alwaysSync":true}`); rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if _, err := os.Lstat(filepath.Join(targetDir, "local.md")); err != nil {
t.Fatalf("expected an up-to-date pull with alwaysSync to sync targets: %v", err)
}
}
func TestHandlePull_EmptyRemoteReturnsCode(t *testing.T) {
s, src := newTestServer(t)
initServerGitRepo(t, src)
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, src, "remote", "add", "origin", remote)
rr := postPull(s, `{}`)
if rr.Code != http.StatusBadRequest || !strings.Contains(rr.Body.String(), `"error_code":"remote_empty"`) {
t.Fatalf("expected 400 with remote_empty, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandlePull_ReportsExtrasSyncWarnings(t *testing.T) {
s, _, remote, _ := setupExtrasScopePull(t)
pushRemoteFile(t, remote, "other/readme.md", "# other\n")
rr := postPull(s, `{}`)
if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), "Source directory does not exist") {
t.Fatalf("expected the missing extra source reported as a warning, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandlePull_RootScopeSyncsExtras(t *testing.T) {
s, _ := newTestServer(t)
root := config.BaseDir()
if err := os.MkdirAll(filepath.Join(root, "skills"), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("SKILLSHARE_CONFIG", filepath.Join(root, "config.yaml"))
targetDir := t.TempDir()
cfg := "git_root: root\nsource: " + filepath.Join(root, "skills") + "\nmode: merge\ntargets: {}\nextras:\n - name: rules\n targets:\n - path: " + targetDir + "\n"
if err := os.WriteFile(config.ConfigPath(), []byte(cfg), 0o644); err != nil {
t.Fatal(err)
}
initServerGitRepo(t, root)
if err := os.WriteFile(filepath.Join(root, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, root, "add", ".gitignore")
testutil.RunGit(t, root, "commit", "-m", "ignore config")
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, root, "remote", "add", "origin", remote)
testutil.RunGit(t, root, "push", "-u", "origin", "HEAD")
pushRemoteFile(t, remote, "extras/rules/team.md", "# team rule\n")
if rr := postPull(s, `{}`); rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if _, err := os.Lstat(filepath.Join(targetDir, "team.md")); err != nil {
t.Fatalf("expected the pulled extra synced to its target: %v", err)
}
}
func TestHandlePull_RootScopeKeepsLocalConfig(t *testing.T) {
s, _ := newTestServer(t)
root := config.BaseDir()
if err := os.MkdirAll(filepath.Join(root, "skills"), 0o755); err != nil {
t.Fatal(err)
}
t.Setenv("SKILLSHARE_CONFIG", filepath.Join(root, "config.yaml"))
setServerGitRoot(t, "root", filepath.Join(root, "skills"))
localConfig, err := os.ReadFile(config.ConfigPath())
if err != nil {
t.Fatal(err)
}
initServerGitRepo(t, root)
if err := os.WriteFile(filepath.Join(root, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, root, "add", ".gitignore")
testutil.RunGit(t, root, "commit", "-m", "ignore config")
remote := filepath.Join(t.TempDir(), "remote.git")
testutil.RunGit(t, "", "init", "--bare", remote)
testutil.RunGit(t, root, "remote", "add", "origin", remote)
testutil.RunGit(t, root, "push", "-u", "origin", "HEAD")
other := filepath.Join(t.TempDir(), "other")
testutil.RunGit(t, "", "clone", remote, other)
testutil.ConfigureGitUser(t, other)
if err := os.WriteFile(filepath.Join(other, "config.yaml"), []byte("source: /other/machine\n"), 0o644); err != nil {
t.Fatal(err)
}
testutil.RunGit(t, other, "add", "-f", "config.yaml")
testutil.RunGit(t, other, "commit", "-m", "track config by mistake")
testutil.RunGit(t, other, "push", "origin", "HEAD")
rr := postPull(s, `{}`)
if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), "remote tracks config.yaml") {
t.Fatalf("expected 200 with a config.yaml warning, got %d: %s", rr.Code, rr.Body.String())
}
if got, err := os.ReadFile(config.ConfigPath()); err != nil || string(got) != string(localConfig) {
t.Fatalf("config.yaml = %q, %v; want this machine's copy kept", got, err)
}
}