mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* 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.
902 lines
32 KiB
Go
902 lines
32 KiB
Go
package git
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestCheckUnpushedConfigHistory(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
path string
|
|
published bool
|
|
remove bool
|
|
wantUnsafe bool
|
|
}{
|
|
{"add file", "config.yaml", false, false, true},
|
|
{"add tree", "config.yaml/nested/local.yaml", false, false, true},
|
|
{"modify published file", "config.yaml", true, false, true},
|
|
{"modify published tree", "config.yaml/nested/local.yaml", true, false, true},
|
|
{"remove published file", "config.yaml", true, true, false},
|
|
{"remove published tree", "config.yaml/nested/local.yaml", true, true, false},
|
|
{"remove unpushed file", "config.yaml", false, true, true},
|
|
{"nested resource config", "skills/config.yaml", false, false, false},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "initial")
|
|
gitExec(t, dir, "remote", "add", "origin", filepath.Join(t.TempDir(), "remote.git"))
|
|
path := filepath.Join(dir, tc.path)
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(path, []byte("first\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "--", tc.path)
|
|
gitExec(t, dir, "commit", "-m", "add config")
|
|
if tc.published {
|
|
gitExec(t, dir, "update-ref", "refs/remotes/origin/main", "HEAD")
|
|
} else {
|
|
gitExec(t, dir, "update-ref", "refs/remotes/origin/main", "HEAD^")
|
|
}
|
|
gitExec(t, dir, "branch", "--set-upstream-to=origin/main")
|
|
if tc.remove {
|
|
gitExec(t, dir, "rm", "-r", "--cached", "--", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "stop tracking")
|
|
} else if tc.published {
|
|
if err := os.WriteFile(path, []byte("second\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "--", tc.path)
|
|
gitExec(t, dir, "commit", "-m", "modify config")
|
|
}
|
|
err := CheckUnpushedConfigHistory(dir)
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if errors.As(err, &historyErr) != tc.wantUnsafe {
|
|
t.Fatalf("CheckUnpushedConfigHistory() = %v; wantUnsafe=%t", err, tc.wantUnsafe)
|
|
}
|
|
if !tc.wantUnsafe && err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if historyErr != nil && (len(historyErr.Commits) != 1 || !historyErr.HasUpstream) {
|
|
t.Fatalf("unexpected offending commits/upstream: %+v", historyErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_FirstPush(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
if err := CheckUnpushedConfigHistory(dir); err != nil {
|
|
t.Fatalf("unborn branch: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "initial config")
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || historyErr.HasUpstream || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("first push = %v; want initial commit refused without upstream", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_Renames(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
if err := os.WriteFile(filepath.Join(dir, "note.yaml"), []byte("local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "note.yaml")
|
|
gitExec(t, dir, "commit", "-m", "initial")
|
|
gitExec(t, dir, "mv", "note.yaml", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "rename to config")
|
|
gitExec(t, dir, "mv", "config.yaml", "note.yaml")
|
|
gitExec(t, dir, "commit", "-m", "rename away from config")
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("renames = %v; want only rename into config refused", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_MergeAddsConfig(t *testing.T) {
|
|
dir := initTestRepo(t)
|
|
gitExec(t, dir, "branch", "-M", "main")
|
|
gitExec(t, dir, "checkout", "-b", "side")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "side")
|
|
gitExec(t, dir, "checkout", "main")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "main")
|
|
gitExec(t, dir, "merge", "--no-ff", "--no-commit", "side")
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("merge-local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "merge with config")
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("merge = %v; want config introduced by merge refused", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_NoUpstreamIgnoresPublishedConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
remote := filepath.Join(t.TempDir(), "origin.git")
|
|
gitExec(t, dir, "init", "--bare", remote)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", remote)
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("published\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "published config")
|
|
gitExec(t, dir, "push", "origin", "main")
|
|
gitExec(t, dir, "rm", "--cached", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "Keep config.yaml out of version control")
|
|
if err := CheckUnpushedConfigHistory(dir); err != nil {
|
|
t.Fatalf("published config with only a local deletion = %v; want allowed", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_StaleRemoteRefAfterRewrite(t *testing.T) {
|
|
dir := t.TempDir()
|
|
remote := filepath.Join(t.TempDir(), "origin.git")
|
|
gitExec(t, dir, "init", "--bare", remote)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", remote)
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "initial")
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("leaked\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
gitExec(t, dir, "push", "-u", "origin", "main")
|
|
// Another machine rewrites the remote to drop the leak; this clone has not fetched.
|
|
gitExec(t, remote, "update-ref", "refs/heads/main", "main^")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "later work")
|
|
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("stale remote-tracking ref = %v; want the leaked commit refused", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_ChecksEveryPushURL(t *testing.T) {
|
|
dir := t.TempDir()
|
|
fetch := filepath.Join(t.TempDir(), "fetch.git")
|
|
mirror := filepath.Join(t.TempDir(), "mirror.git")
|
|
gitExec(t, dir, "init", "--bare", fetch)
|
|
gitExec(t, dir, "init", "--bare", mirror)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", fetch)
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("leaked\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
gitExec(t, dir, "push", "-u", "origin", "main")
|
|
// The fetch URL already has the leak, but push also goes to an empty mirror.
|
|
gitExec(t, dir, "remote", "set-url", "--add", "--push", "origin", fetch)
|
|
gitExec(t, dir, "remote", "set-url", "--add", "--push", "origin", mirror)
|
|
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("push URL without the commit = %v; want the leaked commit refused", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_IgnoresReplaceRefs(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "initial")
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("leaked\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
gitExec(t, dir, "branch", "clean", "HEAD^")
|
|
gitExec(t, dir, "checkout", "clean")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "sanitized")
|
|
gitExec(t, dir, "checkout", "main")
|
|
// git log would read the sanitized replacement; push still sends the original.
|
|
gitExec(t, dir, "replace", "main", "clean")
|
|
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("replaced commit = %v; want the original leaked commit refused", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_BehindRemoteAllowsPublishedConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
remote := filepath.Join(t.TempDir(), "origin.git")
|
|
gitExec(t, dir, "init", "--bare", remote)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", remote)
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("published\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "published config")
|
|
gitExec(t, dir, "rm", "--cached", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "Keep config.yaml out of version control")
|
|
gitExec(t, dir, "push", "-u", "origin", "main")
|
|
other := t.TempDir()
|
|
gitExec(t, other, "clone", "-b", "main", remote, ".")
|
|
gitExec(t, other, "commit", "--allow-empty", "-m", "other machine")
|
|
gitExec(t, other, "push", "origin", "HEAD:main")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "local work")
|
|
|
|
// The remote tip is unknown here, so the push is rejected as non-fast-forward
|
|
// and `push --pull` must be allowed to pull first.
|
|
if err := CheckUnpushedConfigHistory(dir); err != nil {
|
|
t.Fatalf("behind remote with published config = %v; want allowed", err)
|
|
}
|
|
}
|
|
|
|
func TestCheckUnpushedConfigHistory_GoneUpstreamChecksOrigin(t *testing.T) {
|
|
dir := t.TempDir()
|
|
origin := filepath.Join(t.TempDir(), "origin.git")
|
|
fork := filepath.Join(t.TempDir(), "fork.git")
|
|
gitExec(t, dir, "init", "--bare", origin)
|
|
gitExec(t, dir, "init", "--bare", fork)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", origin)
|
|
gitExec(t, dir, "remote", "add", "fork", fork)
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("leaked\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
gitExec(t, dir, "push", "-u", "fork", "main")
|
|
// Upstream config remains but @{u} no longer resolves, so PushArgs pushes to origin.
|
|
gitExec(t, dir, "update-ref", "-d", "refs/remotes/fork/main")
|
|
|
|
var historyErr *UnpushedConfigHistoryError
|
|
if err := CheckUnpushedConfigHistory(dir); !errors.As(err, &historyErr) || len(historyErr.Commits) != 1 {
|
|
t.Fatalf("gone upstream = %v; want the commit refused because origin lacks it", err)
|
|
}
|
|
}
|
|
|
|
func TestPushArgs_IgnoresPushDefaults(t *testing.T) {
|
|
for _, mode := range []string{"current", "matching"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
origin := filepath.Join(t.TempDir(), "origin.git")
|
|
backup := filepath.Join(t.TempDir(), "backup.git")
|
|
gitExec(t, dir, "init", "--bare", origin)
|
|
gitExec(t, dir, "init", "--bare", backup)
|
|
gitExec(t, dir, "init", "-b", "main")
|
|
gitExec(t, dir, "remote", "add", "origin", origin)
|
|
gitExec(t, dir, "remote", "add", "backup", backup)
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "initial")
|
|
gitExec(t, dir, "push", "-u", "origin", "main")
|
|
gitExec(t, dir, "branch", "private")
|
|
gitExec(t, dir, "push", "origin", "private")
|
|
gitExec(t, dir, "checkout", "private")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "unchecked private commit")
|
|
gitExec(t, dir, "checkout", "main")
|
|
gitExec(t, dir, "commit", "--allow-empty", "-m", "checked commit")
|
|
gitExec(t, dir, "config", "remote.pushDefault", "backup")
|
|
gitExec(t, dir, "config", "push.default", mode)
|
|
|
|
gitExec(t, dir, append([]string{}, PushArgs(dir, nil)...)...)
|
|
|
|
if out, _ := exec.Command("git", "-C", backup, "rev-parse", "--verify", "-q", "main").Output(); len(out) > 0 {
|
|
t.Errorf("push went to backup; want the upstream remote only")
|
|
}
|
|
got, _ := exec.Command("git", "-C", origin, "log", "-1", "--format=%s", "private").Output()
|
|
if strings.TrimSpace(string(got)) != "initial" {
|
|
t.Errorf("origin private = %q; want only the current branch pushed", got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func readGitignore(t *testing.T, dir string) string {
|
|
t.Helper()
|
|
b, err := os.ReadFile(filepath.Join(dir, ".gitignore"))
|
|
if err != nil {
|
|
t.Fatalf("read .gitignore: %v", err)
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func TestWriteScopeGitignore_FreshRootExcludesConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := WriteScopeGitignore(dir, "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := readGitignore(t, dir)
|
|
if !strings.Contains(got, "config.yaml") {
|
|
t.Errorf("root .gitignore must exclude config.yaml, got:\n%s", got)
|
|
}
|
|
}
|
|
|
|
func TestWriteScopeGitignore_FreshNonRootOmitsConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := WriteScopeGitignore(dir, "skills"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := readGitignore(t, dir)
|
|
if strings.Contains(got, "config.yaml") {
|
|
t.Errorf("non-root .gitignore must not mention config.yaml, got:\n%s", got)
|
|
}
|
|
}
|
|
|
|
func TestWriteScopeGitignore_AppendsToExistingAtRoot(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gi := filepath.Join(dir, ".gitignore")
|
|
if err := os.WriteFile(gi, []byte("node_modules/\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := WriteScopeGitignore(dir, "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := readGitignore(t, dir)
|
|
if !strings.Contains(got, "config.yaml") {
|
|
t.Errorf("existing root .gitignore must gain config.yaml, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, "node_modules/") {
|
|
t.Errorf("existing entries must be preserved, got:\n%s", got)
|
|
}
|
|
}
|
|
|
|
func TestWriteScopeGitignore_IdempotentAtRoot(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := WriteScopeGitignore(dir, "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := WriteScopeGitignore(dir, "root"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := readGitignore(t, dir)
|
|
if n := strings.Count(got, "config.yaml"); n != 1 {
|
|
t.Errorf("config.yaml must appear exactly once, got %d:\n%s", n, got)
|
|
}
|
|
}
|
|
|
|
func gitExec(t *testing.T, dir string, args ...string) {
|
|
t.Helper()
|
|
cmd := exec.Command("git", args...)
|
|
cmd.Dir = dir
|
|
cmd.Env = append(os.Environ(),
|
|
"GIT_AUTHOR_NAME=test", "GIT_AUTHOR_EMAIL=test@test.com",
|
|
"GIT_COMMITTER_NAME=test", "GIT_COMMITTER_EMAIL=test@test.com",
|
|
)
|
|
if out, err := cmd.CombinedOutput(); err != nil {
|
|
t.Fatalf("git %v: %v\n%s", args, err, out)
|
|
}
|
|
}
|
|
|
|
func TestNestedRepos_DetectsSubdirGitOnly(t *testing.T) {
|
|
dir := t.TempDir()
|
|
mustMkdir := func(p string) {
|
|
if err := os.MkdirAll(filepath.Join(dir, p), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
mustMkdir(".git") // the scope repo's own .git — must be ignored
|
|
mustMkdir("skills/.git") // a nested repo — must be detected
|
|
mustMkdir("old/.git.disabled") // already disabled — must be ignored
|
|
mustMkdir("plain/references") // a plain skill dir — must be ignored
|
|
|
|
got, err := NestedRepos(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || got[0] != "skills" {
|
|
t.Errorf("want [skills], got %v", got)
|
|
}
|
|
}
|
|
|
|
func TestEnsureConfigUntracked_RemovesTrackedConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
gitExec(t, dir, "config", "user.email", "t@t.com")
|
|
gitExec(t, dir, "config", "user.name", "t")
|
|
cfgPath := filepath.Join(dir, "config.yaml")
|
|
if err := os.WriteFile(cfgPath, []byte("k: v\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
|
|
removed, err := EnsureConfigUntracked(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !removed {
|
|
t.Error("expected removed=true for a tracked config.yaml")
|
|
}
|
|
if isTracked(dir, "config.yaml") {
|
|
t.Error("config.yaml must no longer be tracked")
|
|
}
|
|
if _, err := os.Stat(cfgPath); err != nil {
|
|
t.Error("config.yaml file must remain on disk after untracking")
|
|
}
|
|
if gi := readGitignore(t, dir); !strings.Contains(gi, "config.yaml") {
|
|
t.Errorf(".gitignore must contain config.yaml, got:\n%s", gi)
|
|
}
|
|
if removed, _ := EnsureConfigUntracked(dir); removed {
|
|
t.Error("second call must be a no-op (removed=false)")
|
|
}
|
|
}
|
|
|
|
func TestEnsureConfigUntracked_OverridesNegatedIgnore(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
gitExec(t, dir, "config", "user.email", "t@t.com")
|
|
gitExec(t, dir, "config", "user.name", "t")
|
|
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("config.yaml\n!config.yaml\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("k: v\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "-A")
|
|
gitExec(t, dir, "commit", "-m", "leak config")
|
|
|
|
if _, err := EnsureConfigUntracked(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "-A")
|
|
if isTracked(dir, "config.yaml") {
|
|
t.Fatalf("git add -A tracked config.yaml again; .gitignore:\n%s", readGitignore(t, dir))
|
|
}
|
|
}
|
|
|
|
func TestDisableNestedRepo_RenamesAndRefusesClobber(t *testing.T) {
|
|
dir := t.TempDir()
|
|
subGit := filepath.Join(dir, "skills", ".git")
|
|
if err := os.MkdirAll(subGit, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := DisableNestedRepo(dir, "skills"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(subGit); !os.IsNotExist(err) {
|
|
t.Error("skills/.git must be renamed away")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "skills", ".git.disabled")); err != nil {
|
|
t.Error("skills/.git.disabled must exist after disabling")
|
|
}
|
|
if gi := readGitignore(t, dir); !strings.Contains(gi, ".git.disabled") {
|
|
t.Errorf(".gitignore must contain .git.disabled, got:\n%s", gi)
|
|
}
|
|
|
|
// A re-created .git plus an existing .git.disabled must not be clobbered.
|
|
if err := os.MkdirAll(subGit, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := DisableNestedRepo(dir, "skills"); err == nil {
|
|
t.Error("expected an error when .git.disabled already exists")
|
|
}
|
|
}
|
|
|
|
// TestDisableNestedRepo_DropsStaleGitlink covers the already-broken repair case:
|
|
// a parent repo that already committed the nested directory as a gitlink (the
|
|
// real-world symptom). Disabling must drop the stale gitlink so a subsequent
|
|
// `git add -A` re-tracks the directory's files as blobs instead of leaving an
|
|
// empty submodule.
|
|
func TestDisableNestedRepo_DropsStaleGitlink(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
gitExec(t, dir, "config", "user.email", "t@t.com")
|
|
gitExec(t, dir, "config", "user.name", "t")
|
|
|
|
// A nested repo with a file, then commit it from the parent — this records
|
|
// "skills" as a gitlink (160000) in the parent index.
|
|
sub := filepath.Join(dir, "skills")
|
|
if err := os.MkdirAll(sub, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, sub, "init")
|
|
gitExec(t, sub, "config", "user.email", "t@t.com")
|
|
gitExec(t, sub, "config", "user.name", "t")
|
|
if err := os.WriteFile(filepath.Join(sub, "SKILL.md"), []byte("# skill\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, sub, "add", "-A")
|
|
gitExec(t, sub, "commit", "-m", "nested")
|
|
gitExec(t, dir, "add", "skills")
|
|
gitExec(t, dir, "commit", "-m", "record gitlink")
|
|
|
|
if !isGitlink(dir, "skills") {
|
|
t.Fatal("setup failed: skills should be a gitlink before disabling")
|
|
}
|
|
|
|
if err := DisableNestedRepo(dir, "skills"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if isGitlink(dir, "skills") {
|
|
t.Error("stale gitlink must be dropped from the index after disabling")
|
|
}
|
|
|
|
// After re-staging, the directory's files are tracked as blobs.
|
|
gitExec(t, dir, "add", "-A")
|
|
out, err := exec.Command("git", "-C", dir, "ls-files", "skills/SKILL.md").Output()
|
|
if err != nil || strings.TrimSpace(string(out)) == "" {
|
|
t.Errorf("skills/SKILL.md must be tracked as a file after disabling, got %q (err %v)", out, err)
|
|
}
|
|
}
|
|
|
|
func TestRemoteTracksConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
gitExec(t, dir, "config", "user.email", "t@t.com")
|
|
gitExec(t, dir, "config", "user.name", "t")
|
|
|
|
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("# test\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "README.md")
|
|
gitExec(t, dir, "commit", "-m", "init")
|
|
|
|
if RemoteTracksConfig(dir, "HEAD") {
|
|
t.Error("expected RemoteTracksConfig to be false when config.yaml is not tracked")
|
|
}
|
|
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("source: x\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
gitExec(t, dir, "add", "config.yaml")
|
|
gitExec(t, dir, "commit", "-m", "add config")
|
|
|
|
if !RemoteTracksConfig(dir, "HEAD") {
|
|
t.Error("expected RemoteTracksConfig to be true when config.yaml is tracked")
|
|
}
|
|
}
|
|
|
|
func TestHasLocalRootConfig(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if HasLocalRootConfig(dir) {
|
|
t.Error("empty dir must not report local root config")
|
|
}
|
|
|
|
// .gitignore ignoring config.yaml
|
|
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !HasLocalRootConfig(dir) {
|
|
t.Error("dir with config.yaml in .gitignore must report local root config")
|
|
}
|
|
|
|
// Remove .gitignore, create config.yaml
|
|
os.Remove(filepath.Join(dir, ".gitignore"))
|
|
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("source: x\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !HasLocalRootConfig(dir) {
|
|
t.Error("dir with config.yaml on disk must report local root config")
|
|
}
|
|
}
|
|
|
|
// rootScopeRepoTrackingRemote makes a root-scope repo (config.yaml ignored,
|
|
// a local config.yaml on disk) whose main branch tracks a bare remote.
|
|
func rootScopeRepoTrackingRemote(t *testing.T) (repo, remote string) {
|
|
t.Helper()
|
|
remote = filepath.Join(t.TempDir(), "remote.git")
|
|
runGit(t, "", "init", "--bare", "-b", "main", remote)
|
|
repo = t.TempDir()
|
|
runGit(t, repo, "init", "-b", "main")
|
|
runGit(t, repo, "config", "user.email", "test@test.com")
|
|
runGit(t, repo, "config", "user.name", "test")
|
|
if err := os.WriteFile(filepath.Join(repo, ".gitignore"), []byte("config.yaml\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runGit(t, repo, "add", ".gitignore")
|
|
runGit(t, repo, "commit", "-m", "scaffold")
|
|
runGit(t, repo, "remote", "add", "origin", remote)
|
|
runGit(t, repo, "push", "-u", "origin", "main")
|
|
if err := os.WriteFile(filepath.Join(repo, "config.yaml"), []byte("LOCAL-config\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return repo, remote
|
|
}
|
|
|
|
// pushFromOtherClone commits files from a separate clone of remote, force-adding
|
|
// them so an ignored config.yaml gets tracked, as another machine might.
|
|
func pushFromOtherClone(t *testing.T, remote string, files map[string]string) {
|
|
t.Helper()
|
|
other := filepath.Join(t.TempDir(), "other")
|
|
runGit(t, "", "clone", remote, other)
|
|
runGit(t, other, "config", "user.email", "other@test.com")
|
|
runGit(t, other, "config", "user.name", "other")
|
|
for rel, content := range files {
|
|
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)
|
|
}
|
|
runGit(t, other, "add", "-f", rel)
|
|
}
|
|
runGit(t, other, "commit", "-m", "other machine")
|
|
runGit(t, other, "push", "origin", "main")
|
|
}
|
|
|
|
func TestKeepLocalConfig_SurvivesPullThatTracksConfig(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "remote-config\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
tracked, err := restore()
|
|
got, _ := os.ReadFile(filepath.Join(repo, "config.yaml"))
|
|
if err != nil || !tracked || string(got) != "LOCAL-config\n" {
|
|
t.Fatalf("restore() = %v, %v; config.yaml = %q, want the local copy kept and tracking reported", tracked, err, got)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_RestoresSymlinkedConfig(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "remote-config\n"})
|
|
real := filepath.Join(t.TempDir(), "dotfiles-config.yaml")
|
|
if err := os.WriteFile(real, []byte("LOCAL-config\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
link := filepath.Join(repo, "config.yaml")
|
|
if err := os.Remove(link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(real, link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if target, err := os.Readlink(link); err != nil || target != real {
|
|
t.Fatalf("config.yaml symlink = %q, %v; want it pointing at %q", target, err, real)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_ReportsNothingWhenRemoteLeavesConfigAlone(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"skills/a/SKILL.md": "# a\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if tracked, err := restore(); err != nil || tracked {
|
|
t.Fatalf("restore() = %v, %v; want false, nil", tracked, err)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_LeavesEditsToUntrackedConfigAlone(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"skills/a/SKILL.md": "# a\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := filepath.Join(repo, "config.yaml")
|
|
if err := os.WriteFile(cfg, []byte("EDITED-during-pull\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := os.ReadFile(cfg); string(got) != "EDITED-during-pull\n" {
|
|
t.Fatalf("config.yaml = %q; want the edit made during the pull kept", got)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_LeavesEditsToTrackedConfigGitLeftAlone(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "LOCAL-config\n"})
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
pushFromOtherClone(t, remote, map[string]string{"skills/a/SKILL.md": "# a\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := filepath.Join(repo, "config.yaml")
|
|
if err := os.WriteFile(cfg, []byte("EDITED-during-pull\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := os.ReadFile(cfg); string(got) != "EDITED-during-pull\n" {
|
|
t.Fatalf("config.yaml = %q; want the edit made during the pull kept", got)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_IgnoresConfigTrackedOnlyLocally(t *testing.T) {
|
|
repo, _ := rootScopeRepoTrackingRemote(t)
|
|
runGit(t, repo, "add", "-f", "config.yaml")
|
|
runGit(t, repo, "commit", "-m", "track config locally")
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if tracked, err := restore(); err != nil || tracked {
|
|
t.Fatalf("restore() = %v, %v; want false, nil when only a local commit tracks config.yaml", tracked, err)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_RestoresAfterAbortedPull(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "remote-config\n", "skills/a/SKILL.md": "# remote\n"})
|
|
if err := os.MkdirAll(filepath.Join(repo, "skills", "a"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(repo, "skills", "a", "SKILL.md"), []byte("# local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runGit(t, repo, "add", "skills")
|
|
runGit(t, repo, "commit", "-m", "local edit")
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err == nil {
|
|
t.Fatal("PullWithEnv() succeeded; want a conflict that aborts the merge")
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, err := os.ReadFile(filepath.Join(repo, "config.yaml")); err != nil || string(got) != "LOCAL-config\n" {
|
|
t.Fatalf("config.yaml = %q, %v; want the local copy restored after the aborted pull", got, err)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_RestoresModeOfIdenticalCopy(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
cfg := filepath.Join(repo, "config.yaml")
|
|
if err := os.Chmod(cfg, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "LOCAL-config\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if info, err := os.Stat(cfg); err != nil || info.Mode().Perm() != 0o600 {
|
|
t.Fatalf("config.yaml mode = %v, %v; want 0600 kept", info.Mode().Perm(), err)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_RestoresOverTrackedDirectory(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml/file": "remote\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, err := os.ReadFile(filepath.Join(repo, "config.yaml")); err != nil || string(got) != "LOCAL-config\n" {
|
|
t.Fatalf("config.yaml = %q, %v; want the local copy restored over the tracked directory", got, err)
|
|
}
|
|
if removed, err := EnsureConfigUntracked(repo); err != nil || !removed {
|
|
t.Fatalf("EnsureConfigUntracked() = %v, %v; want the tracked directory untracked", removed, err)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_KeepsEditMadeAfterCheckout(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "remote-config\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
cfg := filepath.Join(repo, "config.yaml")
|
|
if err := os.WriteFile(cfg, []byte("NEWER-local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := os.ReadFile(cfg); string(got) != "NEWER-local\n" {
|
|
t.Fatalf("config.yaml = %q; want the copy written after checkout kept", got)
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_KeepsSymlinkMadeAfterCheckout(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "remote-config\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
newer := filepath.Join(t.TempDir(), "dotfiles-config.yaml")
|
|
if err := os.WriteFile(newer, []byte("NEWER-local\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
link := filepath.Join(repo, "config.yaml")
|
|
if err := os.Remove(link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(newer, link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := restore(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if target, err := os.Readlink(link); err != nil || target != newer {
|
|
t.Fatalf("config.yaml symlink = %q, %v; want the link made after checkout kept", target, err)
|
|
}
|
|
}
|
|
|
|
func TestConfigGitignoreNeedsRepair_ExplicitEntryUnderBroaderRule(t *testing.T) {
|
|
dir := t.TempDir()
|
|
gitExec(t, dir, "init")
|
|
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("*.yaml\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !ConfigGitignoreNeedsRepair(dir) {
|
|
t.Fatal("ConfigGitignoreNeedsRepair() = false; want true when only *.yaml ignores config.yaml")
|
|
}
|
|
if _, err := EnsureConfigUntracked(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ConfigGitignoreNeedsRepair(dir) {
|
|
t.Fatal("ConfigGitignoreNeedsRepair() = true after EnsureConfigUntracked; want false")
|
|
}
|
|
}
|
|
|
|
func TestKeepLocalConfig_ReportsTrackedCopyWithSameContent(t *testing.T) {
|
|
repo, remote := rootScopeRepoTrackingRemote(t)
|
|
pushFromOtherClone(t, remote, map[string]string{"config.yaml": "LOCAL-config\n"})
|
|
restore, err := KeepLocalConfig(repo)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := PullWithEnv(repo, nil); err != nil {
|
|
t.Fatalf("PullWithEnv() error: %v", err)
|
|
}
|
|
if tracked, err := restore(); err != nil || !tracked {
|
|
t.Fatalf("restore() = %v, %v; want true, nil for a tracked copy with identical bytes", tracked, err)
|
|
}
|
|
}
|