Add private publication attempt records

internal/publish/record_test.go

@@ -0,0 +1,156 @@
+package publish
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func recordGit(t *testing.T, dir string, args ...string) string {
+	t.Helper()
+	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %v: %v: %s", args, err, out)
+	}
+	return string(out)
+}
+
+func recordRepo(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	recordGit(t, dir, "init", "-q")
+	recordGit(t, dir, "config", "user.name", "Test")
+	recordGit(t, dir, "config", "user.email", "test@example.invalid")
+	if err := os.WriteFile(filepath.Join(dir, "file"), []byte("x"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	recordGit(t, dir, "add", "file")
+	recordGit(t, dir, "commit", "-qm", "init")
+	return dir
+}
+
+func TestLoadEvidenceAcceptsPartialAndRejectsMalformedRecords(t *testing.T) {
+	dir := t.TempDir()
+	partial := filepath.Join(dir, "partial.json")
+	if err := os.WriteFile(partial, []byte(`{"format_version":1,"evidence":{}}`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	got, err := LoadEvidence(partial)
+	if err != nil || got != (Evidence{}) {
+		t.Fatalf("partial record = %#v, %v", got, err)
+	}
+	for name, data := range map[string]string{"bad-json": "{", "unsupported": `{"format_version":2,"evidence":{}}`, "type": `{"format_version":1,"evidence":{"tag":false}}`, "trailing": `{"format_version":1,"evidence":{}} {}`} {
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(dir, name)
+			if err := os.WriteFile(path, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			_, err := LoadEvidence(path)
+			var recovery *RecoveryError
+			if !errors.As(err, &recovery) || recovery.Kind != "record_format" {
+				t.Fatalf("LoadEvidence() error=%v", err)
+			}
+		})
+	}
+}
+
+func TestLoadEvidenceReadFailureHasTypedError(t *testing.T) {
+	_, err := LoadEvidence(filepath.Join(t.TempDir(), "missing.json"))
+	var recovery *RecoveryError
+	if !errors.As(err, &recovery) || recovery.Kind != "record_read" || !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("LoadEvidence() error = %v", err)
+	}
+}
+
+func TestSaveEvidenceUsesPrivateUniqueRecordsAndLinkedWorktreeMetadata(t *testing.T) {
+	repo := recordRepo(t)
+	worktree := filepath.Join(t.TempDir(), "linked")
+	recordGit(t, repo, "worktree", "add", "--detach", worktree)
+	evidence := Evidence{Tag: "v1.2.3", Endpoint: "https://user:secret@example.invalid/repo.git"}
+	first, err := SaveEvidence(worktree, "", evidence)
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := SaveEvidence(worktree, "", evidence)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first == second {
+		t.Fatalf("record paths collided: %q", first)
+	}
+	common := recordGit(t, repo, "rev-parse", "--path-format=absolute", "--git-common-dir")
+	wantDir := filepath.Join(strings.TrimSpace(common), "releasekit", "publication-attempts")
+	if filepath.Dir(first) != wantDir {
+		t.Fatalf("record dir=%q want %q", filepath.Dir(first), wantDir)
+	}
+	dirInfo, err := os.Stat(wantDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if dirInfo.Mode().Perm() != 0700 {
+		t.Fatalf("record directory permissions=%o", dirInfo.Mode().Perm())
+	}
+	info, err := os.Stat(first)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Mode().Perm() != 0600 {
+		t.Fatalf("record permissions=%o", info.Mode().Perm())
+	}
+	loaded, err := LoadEvidence(first)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if loaded.Endpoint != evidence.Endpoint || loaded.RecordedAt == "" {
+		t.Fatalf("loaded evidence=%#v", loaded)
+	}
+	var envelope map[string]json.RawMessage
+	data, err := os.ReadFile(first)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(data, &envelope); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "user:secret@example.invalid") {
+		t.Fatal("private record did not retain the exact endpoint")
+	}
+}
+
+func TestSaveEvidenceResolvesRelativeAndIgnoredOverrides(t *testing.T) {
+	repo := recordRepo(t)
+	if err := os.WriteFile(filepath.Join(repo, ".gitignore"), []byte("saved-records/\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := SaveEvidence(repo, "saved-records", Evidence{Tag: "v1.2.3"}); err != nil {
+		t.Fatalf("ignored override: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(repo, "saved-records")); err != nil {
+		t.Fatal(err)
+	}
+	external := filepath.Join(t.TempDir(), "external-store")
+	path, err := SaveEvidence(repo, external, Evidence{Tag: "v2.0.0"})
+	if err != nil || !strings.HasPrefix(path, external+string(filepath.Separator)) {
+		t.Fatalf("absolute external override path=%q error=%v", path, err)
+	}
+}
+
+func TestSaveEvidenceRejectsUnignoredOverrideInsideWorktree(t *testing.T) {
+	repo := recordRepo(t)
+	_, err := SaveEvidence(repo, "records", Evidence{Tag: "v1.2.3"})
+	var recovery *RecoveryError
+	if !errors.As(err, &recovery) || recovery.Kind != "record_write" {
+		t.Fatalf("SaveEvidence() error=%v", err)
+	}
+	if _, err := os.Stat(filepath.Join(repo, "records")); err != nil {
+		t.Fatalf("expected parent directory to exist without record: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(repo, "records", "attempt")); !os.IsNotExist(err) {
+		t.Fatalf("unexpected record: %v", err)
+	}
+}