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": {Index: a}, "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": {Index: a}, "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": {Index: a}, "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})
}
}