ReleaseKit/repository_test.go

package releasekit_test

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

	releasekit "gitea.maximumdirect.net/eric/ReleaseKit"
)

func TestModuleSelectionFollowsSymlinkBeforeParentAcrossOperations(t *testing.T) {
	repository := newTaggedDeliveryConsumer(t)
	const version = "v1.2.3"
	const modulePath = "example.com/nested"
	const note = "# Fixture v1.2.3\n\nNested release.\n"
	addNestedReleaseModule(t, repository, "nested", modulePath, version)
	writeFile(t, repository, "nested/docs/releases/"+version+".md", note)
	writeFile(t, repository, "nested/deep/placeholder", "tracked directory\n")
	if err := os.Symlink("nested/deep", filepath.Join(repository, "link")); err != nil {
		t.Fatal(err)
	}
	buildGit(t, repository, "add", ".")
	buildGit(t, repository, "commit", "-m", "Add linked nested module")
	wantDir := filepath.Join(repository, "nested")
	wantTag := "nested/" + version
	built, err := releasekit.Build(t.Context(), releasekit.BuildRequest{
		RepositoryDir: repository, ModuleDir: "link/..", Version: version,
	})
	if err != nil || built.ModuleDir != wantDir || built.ModulePath != modulePath || built.Tag != wantTag {
		t.Fatalf("build = %#v, error = %v", built, err)
	}
	checked, err := releasekit.Check(t.Context(), releasekit.ReleaseRequest{
		RepositoryDir: repository, ModuleDir: "link/..", Product: "Fixture", Version: version,
	})
	if err != nil || checked.ModuleDir != wantDir || checked.ModulePath != modulePath || checked.Tag != built.Tag {
		t.Fatalf("check = %#v, error = %v", checked, err)
	}
	buildGit(t, repository, "tag", wantTag)
	server, remote := newFacadeDeliveryServer(t, repository)
	defer server.Close()
	remote.tag, remote.noteBody = wantTag, note
	delivered, err := releasekit.Deliver(t.Context(), releasekit.DeliveryRequest{
		RepositoryDir: repository, ModuleDir: "link/..", Product: "Fixture", Version: version,
		ExpectedTag: wantTag, Destination: facadeDeliveryDestination(server.URL),
	})
	if err != nil || delivered.State != releasekit.DeliveryComplete || delivered.ModuleDir != wantDir || delivered.ModulePath != modulePath || delivered.Tag != built.Tag {
		t.Fatalf("delivery = %#v, error = %v", delivered, err)
	}
}

func TestSourceOperationsResolveContainingRepository(t *testing.T) {
	repo := newPublishFixture(t)
	const module = "apps/widget"
	addNestedReleaseModule(t, repo.work, module, "example.com/widget", "v1.2.3")
	gitRun(t, repo.work, "add", ".")
	gitRun(t, repo.work, "commit", "-m", "Add nested module")
	gitRun(t, repo.work, "-c", "remote.origin.mirror=false", "push", "origin", "HEAD:refs/heads/main")
	child := filepath.Join(repo.work, filepath.FromSlash(module))
	t.Setenv("RELEASEKIT_FAIL_FIXTURE_SUITE", "1")
	request := releasekit.ReleaseRequest{RepositoryDir: child, Product: "Sample App", Version: "v1.2.3"}
	captured, err := releasekit.Check(context.Background(), request)
	if err == nil || captured.RepositoryDir != repo.work || captured.ModuleDir != repo.work || captured.ModulePath != "example.com/releasekit-publish-fixture" || captured.Tag != request.Version {
		t.Fatalf("default check = %#v, error = %v; want failing root module", captured, err)
	}
	published, err := releasekit.Publish(context.Background(), request)
	if err == nil || published.State != releasekit.PublicationNotAttempted || published.TagObject != "" || published.Tag != request.Version {
		t.Fatalf("default publication = %#v, error = %v", published, err)
	}
	if refs := gitText(t, repo.bare, "tag", "--list", request.Version); refs != "" {
		t.Fatalf("failing root tag was published: %s", refs)
	}
	for _, selected := range []string{"", module} {
		wantModule, wantPath, wantTag := repo.work, "example.com/releasekit-publish-fixture", request.Version
		if selected != "" {
			wantModule, wantPath, wantTag = child, "example.com/widget", module+"/"+request.Version
		}
		built, err := releasekit.Build(context.Background(), releasekit.BuildRequest{RepositoryDir: child, ModuleDir: selected, Version: request.Version})
		if err != nil || built.RepositoryDir != repo.work || built.ModuleDir != wantModule || built.ModulePath != wantPath || built.Tag != wantTag {
			t.Fatalf("build %q = %#v, error = %v", selected, built, err)
		}
		delivered, err := releasekit.Deliver(context.Background(), releasekit.DeliveryRequest{RepositoryDir: child, ModuleDir: selected, Product: request.Product, Version: request.Version, ExpectedTag: "mismatch"})
		if err == nil || !strings.Contains(err.Error(), "expected delivery tag") || delivered.RepositoryDir != repo.work || delivered.ModuleDir != wantModule || delivered.ModulePath != wantPath || delivered.Tag != wantTag {
			t.Fatalf("delivery %q = %#v, error = %v", selected, delivered, err)
		}
	}
	request.ModuleDir = module
	captured, err = releasekit.Check(context.Background(), request)
	if err != nil || captured.ModuleDir != child || captured.ModulePath != "example.com/widget" || captured.Tag != module+"/"+request.Version {
		t.Fatalf("nested check = %#v, error = %v", captured, err)
	}
	published, err = releasekit.Publish(context.Background(), request)
	if err != nil || published.State != releasekit.PublicationPublished || published.Tag != captured.Tag {
		t.Fatalf("nested publication = %#v, error = %v", published, err)
	}
	if got := gitText(t, repo.bare, "rev-parse", "refs/tags/"+captured.Tag+"^{commit}"); got != captured.Commit {
		t.Fatalf("published commit = %s; want %s", got, captured.Commit)
	}
}

func TestRepositoryResolutionSupportsAliasesAndIndependentWorktrees(t *testing.T) {
	repo := newPublishFixture(t)
	alias := filepath.Join(t.TempDir(), "alias")
	if err := os.Symlink(repo.work, alias); err != nil {
		t.Fatal(err)
	}
	worktree := filepath.Join(t.TempDir(), "worktree")
	gitRun(t, repo.work, "worktree", "add", "--detach", worktree, "HEAD")
	for _, tt := range []struct{ directory, wantRoot string }{{alias, repo.work}, {filepath.Join(worktree, "docs"), worktree}} {
		result, err := releasekit.Build(context.Background(), releasekit.BuildRequest{RepositoryDir: tt.directory, Version: "v1.2.3"})
		if err != nil || result.RepositoryDir != tt.wantRoot || result.ModuleDir != tt.wantRoot || result.CandidateCommit != repo.commit {
			t.Fatalf("build through %q = %#v, error = %v", tt.directory, result, err)
		}
	}
}

func TestDependencyPreparationDoesNotRequireGitCheckout(t *testing.T) {
	directory := t.TempDir()
	writeFile(t, directory, "go.mod", "module example.com/preparation\n\ngo 1.26.0\n")
	if err := releasekit.PrepareBuildDependencies(context.Background(), releasekit.DependencyPreparationRequest{RepositoryDir: directory}); err != nil {
		t.Fatalf("prepare module outside Git checkout: %v", err)
	}
}