Artifact [e1220aec22]

Artifact e1220aec2271750bba16b1837cd1400c1d4925323dabc93faa0213bb14eda915:

• File sim/agent_clone_test.go — part of check-in [ad1d55f5b9] at 2026-05-04 22:05:56 on branch trunk — feat: close three gaps blocking bones go.mod libfossil drop (#137) (#138)

  * feat(leaf/agent): clone-if-absent via Config.CloneFromHubURL (#137 gap A)

  Adds agent.Config.CloneFromHubURL — when set and Config.RepoPath does not yet exist on disk, agent.New clones the leaf repo from the hub HTTP URL before opening it. Matching project-codes between leaf and hub are required for downstream NATS sync subjects to align, so callers that need to bootstrap a leaf against an existing hub no longer have to import libfossil directly for the pre-agent clone step.

  Also exposes agent.CloneRepo(ctx, repoPath, hubURL) as a standalone helper for callers that need a clone independent of agent construction.

  Existing behavior is preserved: when CloneFromHubURL is empty, agent.New errors on missing RepoPath as before (covered by TestAgentNew_RejectsMissingRepoWithoutCloneURL).

  Closes part of #137 (gap A — bones internal/coord/leaf.go).

  * feat(hub): subscribe to fossil-sync NATS subject in NewHub (#137 gap B)

  NewHub now connects a local NATS client to its embedded server and subscribes to "fossil.<project-code>.sync" so peer leaf agents can push xfer requests to the hub over NATS — alongside the existing HTTP path. Previously, achieving this required running a leaf-agent in serve mode on top of the hub (Pull=false, Push=false, Autosync=AutosyncOff, ServeNATSEnabled=true), which transitively pulled libfossil into the consumer's import graph.

  The subscriber is enabled by default. Read-only HTTP-only mirrors that shouldn't accept NATS pushes can opt out via Config.DisableFossilSyncOverNATS.

  Note on naming: the issue brief proposed Config.ServeFossilSyncOverNATS defaulting to true. Go bool zero-value semantics make default-true awkward without pointers, so the inverted-name shape (DisableX, defaults false = enabled) was used instead.

  Closes part of #137 (gap B — bones internal/coord/hub.go).

  * feat(hub): FileToCommit.Perm + CommitOpts.Time pass-through (#137 gap C)

  Adds two additive fields to the public hub commit surface so consumers no longer need libfossil-direct access to preserve executable bits or seed reproducible commit timestamps:

  - hub.FileToCommit.Perm — "x" marks the file executable on the resulting manifest's F-card. Empty preserves prior behavior. Other libfossil perm markers pass through verbatim. - hub.CommitOpts.Time — explicit commit timestamp; zero defaults to time.Now().UTC() at commit time, matching the prior behavior.

  Tests cover round-tripping the executable bit via libfossil.Repo.ListFiles, honoring an explicit time via Timeline, and falling back to "now" on the zero value.

  Closes part of #137 (gap C — bones internal/hub/hub.go seed path).

  * ci: include #137 sim tests in the serve-tests allowlist

  Adds TestAgentNew_ and TestHubNATSFossilSync_ to the sim serve-tests regex in both Makefile and test.yml so the new clone-if-absent and hub-NATS-subscriber tests actually run in CI alongside TestHubLeafE2E. (user: [email protected], size: 2640) [annotate] [blame] [check-ins using]

package sim

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

	libfossil "github.com/danmestas/libfossil"
	_ "github.com/danmestas/libfossil/db/driver/modernc"

	"github.com/danmestas/EdgeSync/hub"
	"github.com/danmestas/EdgeSync/leaf/agent"
)

// TestAgentNew_ClonesWhenRepoAbsent proves that agent.New, given
// Config.CloneFromHubURL, clones the leaf repo from the hub before
// opening it. Locks the contract that downstream consumers (bones)
// rely on to avoid pulling libfossil into their import graph just for
// the pre-agent clone step.
func TestAgentNew_ClonesWhenRepoAbsent(t *testing.T) {
	if testing.Short() {
		t.Skip("hub bootstrap is too slow for -short")
	}

	dir := t.TempDir()
	hubPath := filepath.Join(dir, "hub.fossil")
	leafPath := filepath.Join(dir, "leaf.fossil")

	h, err := hub.NewHub(context.Background(), hub.Config{RepoPath: hubPath})
	if err != nil {
		t.Fatalf("hub.NewHub: %v", err)
	}
	t.Cleanup(func() { _ = h.Stop() })

	serveCtx, serveCancel := context.WithCancel(context.Background())
	defer serveCancel()
	go func() { _ = h.ServeHTTP(serveCtx) }()
	if !waitForHTTP(t, "http://"+h.HTTPAddr()+"/", 2*time.Second) {
		t.Fatal("hub HTTP not ready within 2s")
	}

	hubURL := "http://" + h.HTTPAddr() + "/"

	a, err := agent.New(agent.Config{
		RepoPath:        leafPath,
		CloneFromHubURL: hubURL,
		User:            "leaf",
	})
	if err != nil {
		t.Fatalf("agent.New with CloneFromHubURL: %v", err)
	}
	t.Cleanup(func() { _ = a.Stop() })

	leaf, err := libfossil.Open(leafPath)
	if err != nil {
		t.Fatalf("open cloned leaf repo: %v", err)
	}
	defer leaf.Close()

	leafCode, err := leaf.Config("project-code")
	if err != nil {
		t.Fatalf("leaf project-code: %v", err)
	}

	hubRepo, err := libfossil.Open(hubPath)
	if err != nil {
		t.Fatalf("open hub repo: %v", err)
	}
	defer hubRepo.Close()
	hubCode, err := hubRepo.Config("project-code")
	if err != nil {
		t.Fatalf("hub project-code: %v", err)
	}

	if leafCode == "" {
		t.Fatal("leaf project-code is empty after clone")
	}
	if leafCode != hubCode {
		t.Errorf("project-code mismatch: leaf=%q hub=%q", leafCode, hubCode)
	}
}

// TestAgentNew_RejectsMissingRepoWithoutCloneURL preserves prior behavior:
// when CloneFromHubURL is empty and RepoPath does not exist, agent.New
// surfaces the libfossil.Open error rather than silently bootstrapping.
func TestAgentNew_RejectsMissingRepoWithoutCloneURL(t *testing.T) {
	dir := t.TempDir()
	leafPath := filepath.Join(dir, "leaf.fossil")

	if _, err := agent.New(agent.Config{RepoPath: leafPath}); err == nil {
		t.Fatal("agent.New on missing repo with no CloneFromHubURL returned nil error")
	}
}