Skip to content
quarry Artifact [830d754fc9]
Login

Artifact [830d754fc9]

Artifact 830d754fc9e5dc3bd261d3e1b24d23113f5ea2a233593434a28fb6206ca4fe4a:


package api

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

	"craftdesign.group/quarry/internal/artifact"
	"craftdesign.group/quarry/internal/index"
	"craftdesign.group/quarry/internal/oltp"
	"craftdesign.group/quarry/internal/ops"
)

// trackerOf is an index holding n tickets, so its last is #n; ids in
// creation order. A ticket whose position is in private is marked so.
func trackerOf(t testing.TB, tag string, n int, private ...int) (*index.Index, []string) {
	t.Helper()
	ix, err := index.Open(filepath.Join(t.TempDir(), tag+".db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { ix.Close() })
	var ps []index.Parsed
	var ids []string
	for i := 1; i <= n; i++ {
		id := fmt.Sprintf("%s%02d%s", tag, i, strings.Repeat("0", 60))
		ids = append(ids, id)
		f := []artifact.Field{{Name: "title", Value: tag + " ticket"}, {Name: "status", Value: "Open"}}
		for _, p := range private {
			if p == i {
				f = append(f, artifact.Field{Name: "is_private", Value: "1"})
			}
		}
		ps = append(ps, index.Parsed{Hash: id, Art: &artifact.Artifact{Type: artifact.Ticket, TicketID: id,
			Date: fmt.Sprintf("2026-10-%02dT10:00:00", i%28+1), User: "dan", Fields: f}})
	}
	if err := ix.FoldNow(ps); err != nil {
		t.Fatal(err)
	}
	return ix, ids
}

// readOnlyNumbers is the numbering store with every method that
// assigns, backfills or scans whole trackers turned into a failure.
type readOnlyNumbers struct {
	TicketNumberStore
	t testing.TB
}

func (r readOnlyNumbers) TicketNumbersAssign(string, []string) error {
	r.t.Errorf("FAIL: ticket.number assigned numbers")
	return nil
}
func (r readOnlyNumbers) TicketNumbers(string) (map[string]int, error) {
	r.t.Errorf("FAIL: ticket.number read a whole tracker's numbering (the backfill path)")
	return nil, nil
}
func (r readOnlyNumbers) TicketNumberRekey(string, string, string) error {
	r.t.Errorf("FAIL: ticket.number rekeyed a number")
	return nil
}
func (r readOnlyNumbers) TicketNumberClaim(string, string, int) (bool, error) {
	r.t.Errorf("FAIL: ticket.number claimed a number")
	return false, nil
}

type numberForge struct {
	r  *ops.Registry
	db *oltp.DB
}

// numberRegistry numbers every repository first (an ordinary read
// does that, never this op), then serves ticket.number over a store
// that fails the test on any write.
func numberRegistry(t testing.TB, repos map[string]*Repo, mutate func(*Deps)) *ops.Registry {
	t.Helper()
	db, err := oltp.Open(filepath.Join(t.TempDir(), "o.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { db.Close() })
	for name, repo := range repos {
		all, err := repo.Index.TicketCreation()
		if err != nil {
			t.Fatal(err)
		}
		var ids []string
		for _, tk := range all {
			ids = append(ids, tk.ID)
		}
		if err := db.TicketNumbersAssign(name, ids); err != nil {
			t.Fatal(err)
		}
	}
	d := Deps{Version: "v", Repos: NewRepos(repos), Numbers: readOnlyNumbers{db, t}}
	if mutate != nil {
		mutate(&d)
	}
	r := ops.NewRegistry()
	if err := RegisterAll(r, d); err != nil {
		t.Fatal(err)
	}
	return r
}

func numberRows(t testing.TB, r *ops.Registry, who string, in ticketNumberIn) []acrossTicket {
	t.Helper()
	ctx := context.Background()
	if who != "" {
		ctx = ops.WithUser(ctx, who)
	}
	out, err := r.Invoke(ctx, "ticket.number", in)
	if err != nil {
		t.Fatal(err)
	}
	return out.(ticketNumberOut).Tickets
}

func rowRepos(rows []acrossTicket) string {
	var out []string
	for _, row := range rows {
		out = append(out, row.Repo)
	}
	return strings.Join(out, " ")
}

func vaultOnlyForDan(ctx context.Context, repo string) bool {
	return repo != "vault" || ops.User(ctx) == "dan"
}

// A number carried in three repositories, one of them private: a
// viewer who cannot read that one gets two rows, each naming its
// repository, and nothing shows the third exists; a member gets three.
// A number carried once is one row, and one nobody carries is none.
// The op writes nothing: the store fails the test if it does.
func TestATicketNumberListsEveryRepositoryThatCarriesIt(t *testing.T) {
	mk := func(tag string, n int) *Repo { ix, _ := trackerOf(t, tag, n); return &Repo{Index: ix} }
	r := numberRegistry(t, map[string]*Repo{
		"shop": mk("aa", 2), "garden": mk("bb", 2), "vault": mk("cc", 2), "solo": mk("dd", 1),
	}, func(d *Deps) { d.CanRead = vaultOnlyForDan })
	if got := rowRepos(numberRows(t, r, "", ticketNumberIn{Number: 2})); got != "garden shop" {
		t.Errorf("FAIL: an anonymous viewer's rows %q, want garden shop", got)
	}
	if got := rowRepos(numberRows(t, r, "eve", ticketNumberIn{Number: 2})); got != "garden shop" {
		t.Errorf("FAIL: a signed-in non-member's rows %q", got)
	}
	if got := rowRepos(numberRows(t, r, "dan", ticketNumberIn{Number: 2})); got != "garden shop vault" {
		t.Errorf("FAIL: a member's rows %q, want three", got)
	}
	if got := rowRepos(numberRows(t, r, "", ticketNumberIn{Number: 1})); got != "garden shop solo" {
		t.Errorf("FAIL: #1 rows %q", got)
	}
	if got := rowRepos(numberRows(t, r, "", ticketNumberIn{Number: 2, Repo: "shop"})); got != "shop" {
		t.Errorf("FAIL: repo narrowing gave %q", got)
	}
	if rows := numberRows(t, r, "", ticketNumberIn{Number: 9}); len(rows) != 0 {
		t.Errorf("FAIL: #9 names %+v", rows)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// Only the private repository carries the number: nobody who cannot
// read it learns it carries anything.
func TestATicketNumberOnlyAPrivateRepositoryCarries(t *testing.T) {
	a, _ := trackerOf(t, "aa", 1)
	c, _ := trackerOf(t, "cc", 4)
	r := numberRegistry(t, map[string]*Repo{"shop": {Chat: "shop", Index: a}, "vault": {Chat: "vault", Index: c}},
		func(d *Deps) { d.CanRead = vaultOnlyForDan })
	if rows := numberRows(t, r, "", ticketNumberIn{Number: 4}); len(rows) != 0 {
		t.Errorf("FAIL: an anonymous viewer was shown %+v", rows)
	}
	if rows := numberRows(t, r, "dan", ticketNumberIn{Number: 4}); len(rows) != 1 || rows[0].Repo != "vault" {
		t.Errorf("FAIL: the member's rows %+v", rows)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// A private TICKET inside a public repository follows that
// repository's e letter, not just its readability.
func TestATicketNumberHidesAPrivateTicketInAPublicRepository(t *testing.T) {
	a, _ := trackerOf(t, "aa", 2, 2)
	b, _ := trackerOf(t, "bb", 2)
	r := numberRegistry(t, map[string]*Repo{"shop": {Chat: "shop", Index: a}, "garden": {Chat: "garden", Index: b}}, func(d *Deps) {
		d.CapsFor = func(account, repo string) CapSet {
			if account == "dan" {
				return oltp.CapSet("e")
			}
			return oltp.CapSet("3")
		}
	})
	for who, want := range map[string]string{"": "garden", "eve": "garden", "dan": "garden shop"} {
		if got := rowRepos(numberRows(t, r, who, ticketNumberIn{Number: 2})); got != want {
			t.Errorf("FAIL: %q sees %q, want %q", who, got, want)
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// A repository under a takedown hold serves nothing here.
func TestATicketNumberSkipsAHeldRepository(t *testing.T) {
	a, _ := trackerOf(t, "aa", 2)
	b, _ := trackerOf(t, "bb", 2)
	r := numberRegistry(t, map[string]*Repo{"shop": {Chat: "shop", Index: a}, "garden": {Chat: "garden", Index: b}}, func(d *Deps) {
		d.Held = func(_ context.Context, repo string) string {
			if repo == "shop" {
				return "held"
			}
			return ""
		}
	})
	if got := rowRepos(numberRows(t, r, "", ticketNumberIn{Number: 2})); got != "garden" {
		t.Errorf("FAIL: rows %q, a held repository must serve nothing", got)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// A hundred repositories answer without a write, within a bound that
// is loose but would catch a per-repository full scan under a lock.
func TestATicketNumberOverAHundredRepositories(t *testing.T) {
	repos := map[string]*Repo{}
	for i := 0; i < 100; i++ {
		ix, _ := trackerOf(t, fmt.Sprintf("r%02d", i), 3)
		repos[fmt.Sprintf("repo%03d", i)] = &Repo{Index: ix}
	}
	r := numberRegistry(t, repos, nil)
	start := time.Now()
	rows := numberRows(t, r, "", ticketNumberIn{Number: 2})
	took := time.Since(start)
	if len(rows) != 100 {
		t.Errorf("FAIL: %d rows over 100 repositories", len(rows))
	}
	if took > 5*time.Second {
		t.Errorf("FAIL: took %v", took)
	}
	t.Logf("ok: 100 repositories answered in %v", took)
}

func BenchmarkTicketNumberAcrossAHundredRepositories(b *testing.B) {
	repos := map[string]*Repo{}
	for i := 0; i < 100; i++ {
		ix, _ := trackerOf(b, fmt.Sprintf("r%02d", i), 3)
		repos[fmt.Sprintf("repo%03d", i)] = &Repo{Index: ix}
	}
	r := numberRegistry(b, repos, nil)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		numberRows(b, r, "", ticketNumberIn{Number: 2})
	}
}