acquisition_test.go

package app

import (
	"context"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/morluto/gitcontribute/internal/codeindex"
	"github.com/morluto/gitcontribute/internal/contracts"
	"github.com/morluto/gitcontribute/internal/domain"
)

func newTestRemote(t *testing.T) (remoteURL, baseSHA string) {
	t.Helper()
	dir := t.TempDir()
	remote := filepath.Join(dir, "remote.git")
	runGitApp(t, "", "init", "--bare", remote)

	src := filepath.Join(dir, "src")
	runGitApp(t, "", "clone", remote, src)
	runGitApp(t, src, "config", "user.email", "test@example.com")
	runGitApp(t, src, "config", "user.name", "Test")

	writeAppFile(t, filepath.Join(src, "main.go"), "package main\n")
	runGitApp(t, src, "add", ".")
	runGitApp(t, src, "commit", "-m", "initial")
	runGitApp(t, src, "push", "origin", "master")

	baseSHA = strings.TrimSpace(runGitApp(t, src, "rev-parse", "master"))
	runGitApp(t, remote, "symbolic-ref", "HEAD", "refs/heads/master")
	return remote, baseSHA
}

func pushCommit(t *testing.T, remote, file, content, message string) string {
	t.Helper()
	dir := t.TempDir()
	src := filepath.Join(dir, "src")
	runGitApp(t, "", "clone", remote, src)
	runGitApp(t, src, "config", "user.email", "test@example.com")
	runGitApp(t, src, "config", "user.name", "Test")

	writeAppFile(t, filepath.Join(src, file), content)
	runGitApp(t, src, "add", ".")
	runGitApp(t, src, "commit", "-m", message)
	runGitApp(t, src, "push", "origin", "master")

	return strings.TrimSpace(runGitApp(t, src, "rev-parse", "master"))
}

func TestAcquireSuccess(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	remote, baseSHA := newTestRemote(t)

	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	res, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "testowner", Repo: "testrepo"}, remote)
	if err != nil {
		t.Fatalf("acquire: %v", err)
	}
	if res.CommitSHA != baseSHA {
		t.Fatalf("commit sha mismatch: got %q want %q", res.CommitSHA, baseSHA)
	}
	if res.DefaultBranch != "master" {
		t.Fatalf("default branch: got %q want master", res.DefaultBranch)
	}
	if !res.Indexed {
		t.Fatal("expected indexed")
	}
	if !res.Inserted {
		t.Fatal("expected inserted")
	}
	if res.Files != 1 {
		t.Fatalf("files: got %d want 1", res.Files)
	}

	c, err := svc.openCorpus(ctx)
	if err != nil {
		t.Fatalf("open corpus: %v", err)
	}
	snap, err := c.LatestCodeSnapshot(ctx, domain.MustRepoRef("testowner", "testrepo"))
	if err != nil {
		t.Fatalf("latest snapshot: %v", err)
	}
	if snap == nil || snap.CommitSHA != baseSHA {
		t.Fatalf("snapshot not stored: %+v", snap)
	}
}

func TestAcquireRepeatFetch(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	remote, baseSHA := newTestRemote(t)

	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	res1, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "owner", Repo: "repo"}, remote)
	if err != nil {
		t.Fatalf("first acquire: %v", err)
	}
	if res1.CommitSHA != baseSHA {
		t.Fatalf("first commit sha: got %q want %q", res1.CommitSHA, baseSHA)
	}

	newSHA := pushCommit(t, remote, "feature.go", "package feature\n", "add feature")

	res2, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "owner", Repo: "repo"}, remote)
	if err != nil {
		t.Fatalf("second acquire: %v", err)
	}
	if res2.CommitSHA != newSHA {
		t.Fatalf("second commit sha: got %q want %q", res2.CommitSHA, newSHA)
	}
	if !res2.Inserted {
		t.Fatal("expected new snapshot to be inserted")
	}

	c, err := svc.openCorpus(ctx)
	if err != nil {
		t.Fatalf("open corpus: %v", err)
	}
	snap, err := c.LatestCodeSnapshot(ctx, domain.MustRepoRef("owner", "repo"))
	if err != nil {
		t.Fatalf("latest snapshot: %v", err)
	}
	if snap == nil || snap.CommitSHA != newSHA {
		t.Fatalf("latest snapshot not updated: %+v", snap)
	}
}

func TestAcquireUnchangedCommitReusesCurrentSnapshot(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	remote, commit := newTestRemote(t)
	ref := contracts.RepoRef{Owner: "owner", Repo: "repo"}

	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	first, err := svc.Acquire(ctx, ref, remote)
	if err != nil {
		t.Fatalf("first acquire: %v", err)
	}
	replacement := codeindex.Snapshot{
		RepoPath: first.Remote,
		Commit:   commit,
		Documents: []codeindex.Document{{
			Path: "sentinel.txt", Content: "preserved sentinel", Bytes: len("preserved sentinel"),
		}},
		TotalBytes: len("preserved sentinel"),
		CreatedAt:  time.Now().UTC(),
		Manifest: codeindex.Manifest{
			FormatVersion:  codeindex.FormatVersion,
			CoverageKnown:  true,
			TrackedEntries: 1,
			IndexedFiles:   1,
		},
	}
	if _, _, err := svc.corpus.StoreCodeSnapshot(
		ctx, domain.MustRepoRef(ref.Owner, ref.Repo), replacement,
	); err != nil {
		t.Fatalf("replace snapshot: %v", err)
	}

	second, err := svc.Acquire(ctx, ref, remote)
	if err != nil {
		t.Fatalf("second acquire: %v", err)
	}
	if second.Inserted || second.Message != "acquired; snapshot already indexed" {
		t.Fatalf("second acquire = %+v", second)
	}
	matches, err := svc.corpus.SearchCode(
		ctx, "sentinel", domain.MustRepoRef(ref.Owner, ref.Repo), 10,
	)
	if err != nil {
		t.Fatalf("search preserved snapshot: %v", err)
	}
	if len(matches) != 1 || matches[0].Path != "sentinel.txt" {
		t.Fatalf("snapshot was reindexed: %+v", matches)
	}
}

func TestAcquireFailureAtomicity(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	_, _ = newTestRemote(t)

	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	_, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "owner", Repo: "repo"}, "/nonexistent/remote/path")
	if err == nil {
		t.Fatal("expected error for invalid remote")
	}

	cacheRoot, err := svc.paths.AcquisitionCacheDir()
	if err != nil {
		t.Fatalf("cache dir: %v", err)
	}
	entries, err := os.ReadDir(filepath.Join(cacheRoot, "mirrors"))
	if err == nil && len(entries) > 0 {
		t.Fatalf("expected no mirror cache after failed clone, got %v", entries)
	}
}

func TestAcquireConcurrent(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	remote, baseSHA := newTestRemote(t)

	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	var wg sync.WaitGroup
	errs := make(chan error, 2)
	commits := make(chan string, 2)

	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			res, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "owner", Repo: "repo"}, remote)
			if err != nil {
				errs <- err
				return
			}
			commits <- res.CommitSHA
		}()
	}
	wg.Wait()
	close(errs)
	close(commits)

	for err := range errs {
		t.Fatalf("concurrent acquire error: %v", err)
	}
	for commit := range commits {
		if commit != baseSHA {
			t.Fatalf("unexpected commit: got %q want %q", commit, baseSHA)
		}
	}
}

func TestAcquireInvalidRepo(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	_, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "", Repo: "repo"}, "/some/remote")
	if err == nil {
		t.Fatal("expected error for invalid repo ref")
	}
}

func TestAcquireInvalidRemote(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	svc := newLocalService(t)
	defer func() { _ = svc.Close() }()

	_, err := svc.Acquire(ctx, contracts.RepoRef{Owner: "owner", Repo: "repo"}, "--unsafe")
	if err == nil {
		t.Fatal("expected error for invalid remote")
	}
}