Artifact [06ec30e07d]

Artifact 06ec30e07d2039d4fa0b1b34aef58dd086b5bc729905b23f7da8f11aeeddf1f6:

• File dst/tag_branch_test.go — part of check-in [6b66ea6b2d] at 2026-05-12 20:01:20 on branch trunk — feat: CreateOpts.ProjectCode — accept explicit project-code on Create (#31)

  * feat: CreateOpts.ProjectCode — accept explicit project-code on Create

  Downstream EdgeSync coordinates a shared project-code across sibling Fossil repos created on different machines so its NATS sync subject ("<prefix>.<project-code>.sync") matches across leaves. Today every Create generates a fresh project-code, so commits never propagate.

  Add CreateOpts.ProjectCode: empty preserves current behavior; non-empty must be 40-char lowercase hex (^[0-9a-f]{40}$) — the same format generated project-codes use. Validation runs at the top of libfossil.Create before any disk I/O, so invalid input cannot leave a half-written file behind. Server-code stays auto-generated.

  Threaded through repo.Create / repo.CreateWithEnv / db.SeedConfig. SeedConfig validates as defense-in-depth (public package, multiple callers possible).

  Clone accepting ProjectCode is out of scope; will follow separately if EdgeSync needs it.

  * test: round-trip explicit ProjectCode through fossil rebuild

  Asserts that vanilla `fossil` (2.28) accepts a Go-side repo created with an explicit ProjectCode, and that `fossil sql` reads back the same value we set. Closes the gap where the existing TestCreate_FossilValidation only covered the generated-project-code path. (user: [email protected], size: 6720) [annotate] [blame] [check-ins using]

package dst

import (
	"path/filepath"
	"testing"
	"time"

	"github.com/danmestas/libfossil/internal/branch"
	"github.com/danmestas/libfossil/internal/manifest"
	"github.com/danmestas/libfossil/internal/repo"
	"github.com/danmestas/libfossil/simio"
)

// TestTagPropagationAcrossSync creates checkins with inline T-cards on the
// master, syncs to leaves, and verifies tagxref entries propagated correctly.
func TestTagPropagationAcrossSync(t *testing.T) {
	masterRepo := createMasterRepo(t)
	mf := NewMockFossil(masterRepo)

	// Create checkins via manifest.Checkin.
	parentRid, _, err := manifest.Checkin(masterRepo, manifest.CheckinOpts{
		Files:   []manifest.File{{Name: "hello.txt", Content: []byte("hello world")}},
		Comment: "initial commit with tags",
		User:    "testuser",
		Time:    time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("Checkin initial: %v", err)
	}

	// Second commit — should inherit branch=trunk via tag propagation.
	_, _, err = manifest.Checkin(masterRepo, manifest.CheckinOpts{
		Files:   []manifest.File{{Name: "hello.txt", Content: []byte("hello world v2")}},
		Comment: "second commit",
		User:    "testuser",
		Parent:  parentRid,
		Time:    time.Date(2024, 1, 15, 11, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("Checkin second: %v", err)
	}

	// Verify tagxref integrity on master before sync.
	if err := CheckTagxrefIntegrity("master", masterRepo); err != nil {
		t.Fatalf("master tagxref integrity: %v", err)
	}

	// Run simulation: master -> 2 leaves.
	sim, err := New(SimConfig{
		Seed:         42,
		NumLeaves:    2,
		PollInterval: 5 * time.Second,
		TmpDir:       t.TempDir(),
		Upstream:     mf,
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	defer sim.Close()

	if err := sim.Run(30); err != nil {
		t.Fatalf("Run: %v", err)
	}
	t.Logf("Simulation: %d steps, %d syncs, %d errors", sim.Steps, sim.TotalSyncs, sim.TotalErrors)

	// After sync, run Crosslink on each leaf to process received manifests.
	for _, id := range sim.LeafIDs() {
		leafRepo := sim.Leaf(id).Repo()

		n, err := manifest.Crosslink(leafRepo)
		if err != nil {
			t.Fatalf("Crosslink %s: %v", id, err)
		}
		t.Logf("%s: crosslinked %d artifacts", id, n)

		// Verify tagxref integrity on each leaf.
		if err := CheckTagxrefIntegrity(string(id), leafRepo); err != nil {
			t.Errorf("tagxref integrity %s: %v", id, err)
		}

		// Verify branch=trunk tag exists on at least the initial checkin.
		var branchCount int
		leafRepo.DB().QueryRow(
			"SELECT count(*) FROM tagxref JOIN tag USING(tagid) WHERE tagname='branch' AND value='trunk'",
		).Scan(&branchCount)
		if branchCount == 0 {
			t.Errorf("%s: no branch=trunk tagxref entries after sync", id)
		} else {
			t.Logf("%s: %d branch=trunk tagxref entries", id, branchCount)
		}
	}
}

// TestBranchCreateAndSync creates a branch on the master, syncs to leaves,
// and verifies the branch is visible via branch.List on each leaf.
func TestBranchCreateAndSync(t *testing.T) {
	masterRepo := createMasterRepo(t)
	mf := NewMockFossil(masterRepo)

	// Create initial checkin on trunk.
	parentRid, _, err := manifest.Checkin(masterRepo, manifest.CheckinOpts{
		Files:   []manifest.File{{Name: "main.go", Content: []byte("package main")}},
		Comment: "initial commit",
		User:    "testuser",
		Time:    time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("Checkin: %v", err)
	}

	// Create a branch.
	_, _, err = branch.Create(masterRepo, branch.CreateOpts{
		Name:   "feature-x",
		Parent: parentRid,
		User:   "testuser",
		Time:   time.Date(2024, 1, 15, 11, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("branch.Create: %v", err)
	}

	// Verify branches on master.
	masterBranches, err := branch.List(masterRepo)
	if err != nil {
		t.Fatalf("master branch.List: %v", err)
	}
	masterNames := map[string]bool{}
	for _, b := range masterBranches {
		masterNames[b.Name] = true
		t.Logf("master branch: %s closed=%v", b.Name, b.IsClosed)
	}
	if !masterNames["feature-x"] {
		t.Fatal("master missing branch feature-x")
	}

	// Verify tagxref integrity on master.
	if err := CheckTagxrefIntegrity("master", masterRepo); err != nil {
		t.Fatalf("master tagxref: %v", err)
	}

	// Run simulation: master -> 2 leaves.
	sim, err := New(SimConfig{
		Seed:         77,
		NumLeaves:    2,
		PollInterval: 5 * time.Second,
		TmpDir:       t.TempDir(),
		Upstream:     mf,
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	defer sim.Close()

	if err := sim.Run(30); err != nil {
		t.Fatalf("Run: %v", err)
	}
	t.Logf("Simulation: %d steps, %d syncs, %d errors", sim.Steps, sim.TotalSyncs, sim.TotalErrors)

	// After sync, crosslink + verify branches on each leaf.
	for _, id := range sim.LeafIDs() {
		leafRepo := sim.Leaf(id).Repo()

		n, err := manifest.Crosslink(leafRepo)
		if err != nil {
			t.Fatalf("Crosslink %s: %v", id, err)
		}
		t.Logf("%s: crosslinked %d artifacts", id, n)

		// Check tagxref integrity.
		if err := CheckTagxrefIntegrity(string(id), leafRepo); err != nil {
			t.Errorf("tagxref integrity %s: %v", id, err)
		}

		// Verify branch is visible via branch.List.
		leafBranches, err := branch.List(leafRepo)
		if err != nil {
			t.Errorf("%s branch.List: %v", id, err)
			continue
		}
		leafNames := map[string]bool{}
		for _, b := range leafBranches {
			leafNames[b.Name] = true
			t.Logf("%s branch: %s closed=%v", id, b.Name, b.IsClosed)
		}
		if !leafNames["feature-x"] {
			t.Errorf("%s: missing branch feature-x after sync", id)
		}
	}
}

// TestTagxrefIntegrityInvariant is a unit test for the invariant itself.
func TestTagxrefIntegrityInvariant(t *testing.T) {
	path := filepath.Join(t.TempDir(), "test.fossil")
	r, err := repo.Create(path, "testuser", simio.CryptoRand{}, "")
	if err != nil {
		t.Fatalf("repo.Create: %v", err)
	}
	defer r.Close()

	// Empty repo should pass.
	if err := CheckTagxrefIntegrity("test", r); err != nil {
		t.Fatalf("empty repo: %v", err)
	}

	// Create a checkin (adds inline T-cards which populate tagxref).
	_, _, err = manifest.Checkin(r, manifest.CheckinOpts{
		Files:   []manifest.File{{Name: "a.txt", Content: []byte("a")}},
		Comment: "test",
		User:    "testuser",
		Time:    time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("Checkin: %v", err)
	}

	// Repo with tags should pass.
	if err := CheckTagxrefIntegrity("test", r); err != nil {
		t.Fatalf("with tags: %v", err)
	}

	// Corrupt: insert tagxref referencing non-existent blob.
	r.DB().Exec("INSERT INTO tagxref(tagid, tagtype, srcid, origid, value, mtime, rid) VALUES(1, 1, 0, 99999, '', 0, 99999)")
	if err := CheckTagxrefIntegrity("test", r); err == nil {
		t.Error("expected invariant violation for non-existent rid")
	}
}