@synopackageland/cli 0.5.3 → 0.6.0

package/dist/templates/native-go/backend/internal/helper/cohort_test.go

@@ -1,372 +0,0 @@
-package helper
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"syscall"
-	"testing"
-	"time"
-)
-
-type operationFixture struct {
-	childFixture
-	stopped bool
-	pending bool
-	stuck   bool
-	leases  int
-}
-
-func (f *operationFixture) chunk(n uint32) error { f.pending = true; f.leases++; return nil }
-func (f *operationFixture) idle() (bool, error)  { return !f.pending, nil }
-func (f *operationFixture) stopRelay() {
-	f.stopped = true
-	if !f.stuck {
-		f.pending = false
-	}
-}
-func (f *operationFixture) relayStopped() bool { return f.stopped && !f.pending }
-
-func cohortFixture(t *testing.T) (*operationCohort, *NativeProvider, SessionCarriers, NativeActor, operationBinding, *[]*operationFixture) {
-	t.Helper()
-	p, _, _, carrier, now := nativeFixture()
-	actor, code := p.Resolve(context.Background(), carrier)
-	if code != "" {
-		t.Fatal(code)
-	}
-	i := Inventory{Package: "Fixture", Version: "1.0.0-0001", Protocol: 2, PayloadDigest: strings.Repeat("d", 64), RegistryDigest: strings.Repeat("e", 64)}
-	gate := newAdmission(Binding{Boot: "boot", Install: "install"})
-	gate.observe(gate.binding, 1, true, now)
-	children := new([]*operationFixture)
-	c := newOperationCohort(i, strings.Repeat("f", 64), 42, gate, func() bool { return true })
-	c.now = func() time.Time { return now }
-	c.startChild = func(a NativeActor, b operationBinding) (operationProcess, error) {
-		f := &operationFixture{childFixture: childFixture{exitOn: syscall.SIGTERM}}
-		*children = append(*children, f)
-		return f, nil
-	}
-	b := operationBinding{Inventory: i, Epoch: c.epoch, OperationID: fmt.Sprintf("%064x", 1), Nonce: fmt.Sprintf("%064x", 2), GrantID: strings.Repeat("1", 64), GrantRevision: 1}
-	return c, p, carrier, actor, b, children
-}
-func TestCohortPeerBindingActorReplayAndLimits(t *testing.T) {
-	for _, name := range []string{"peer", "uid", "inventory", "epoch", "zero-actor", "expired-actor", "root", "groups", "nonce", "revision"} {
-		t.Run(name, func(t *testing.T) {
-			c, p, carrier, a, b, children := cohortFixture(t)
-			peer := operationPeer{PID: 42, UID: 0}
-			switch name {
-			case "peer":
-				peer.PID = 43
-			case "uid":
-				peer.UID = 1
-			case "inventory":
-				b.Inventory.RegistryDigest = strings.Repeat("0", 64)
-			case "epoch":
-				b.Epoch = strings.Repeat("0", 64)
-			case "zero-actor":
-				a = NativeActor{}
-			case "expired-actor":
-				p.now = func() time.Time { return c.now().Add(3 * time.Second) }
-			case "root":
-				a.account.UID = 0
-			case "groups":
-				a.account.Groups = nil
-			case "nonce":
-				b.Nonce = "bad"
-			case "revision":
-				b.GrantRevision = 0
-			}
-			if c.start(context.Background(), peer, p, carrier, a, b) == "" || len(*children) != 0 {
-				t.Fatal("invalid work started")
-			}
-		})
-	}
-	c, p, carrier, a, b, children := cohortFixture(t)
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != ErrReplay {
-		t.Fatal(code)
-	}
-	b.OperationID = fmt.Sprintf("%064x", 3)
-	b.Nonce = fmt.Sprintf("%064x", 4)
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	b.OperationID = fmt.Sprintf("%064x", 5)
-	b.Nonce = fmt.Sprintf("%064x", 6)
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != ErrBusy || len(*children) != 2 {
-		t.Fatal(code)
-	}
-}
-func TestCohortChunkFenceAndCompletion(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	peer := operationPeer{42, 0}
-	if code := c.start(context.Background(), peer, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	if _, err := c.proof(); err == nil {
-		t.Fatal("live cohort completed")
-	}
-	if code := c.chunk(context.Background(), peer, p, carrier, b, MaxChunkBytes); code != "" {
-		t.Fatal(code)
-	}
-	if code := c.chunk(context.Background(), peer, p, carrier, b, 1); code != ErrBusy {
-		t.Fatal(code)
-	}
-	c.gate.fence("fixture")
-	if code := c.chunk(context.Background(), peer, p, carrier, b, 1); code != ErrFenced {
-		t.Fatal(code)
-	}
-	if len((*children)[0].signals) != 0 {
-		t.Fatal("signal preceded durable fence/drain")
-	}
-	if err := c.drain(context.Background(), time.Millisecond); err != nil {
-		t.Fatal(err)
-	}
-	q, err := c.proof()
-	if err != nil || q.Started != 1 || q.Reaped != 1 || !q.RelaysStopped {
-		t.Fatal(q, err)
-	}
-	if !(*children)[0].stopped {
-		t.Fatal("relay survived")
-	}
-	if code := c.start(context.Background(), peer, p, carrier, a, b); code != ErrFenced {
-		t.Fatal(code)
-	}
-}
-func TestCohortUnknownReapAndBlockedRelayNeverComplete(t *testing.T) {
-	for _, kind := range []string{"ECHILD", "relay"} {
-		t.Run(kind, func(t *testing.T) {
-			c, p, carrier, a, b, children := cohortFixture(t)
-			if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != "" {
-				t.Fatal(code)
-			}
-			f := (*children)[0]
-			if kind == "ECHILD" {
-				f.err = syscall.ECHILD
-			} else {
-				f.stuck = true
-				f.pending = true
-			}
-			ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
-			defer cancel()
-			if c.drain(ctx, time.Millisecond) == nil {
-				t.Fatal("unknown quiescence accepted")
-			}
-			if _, err := c.proof(); err == nil {
-				t.Fatal("invalid proof")
-			}
-			if kind == "ECHILD" && len(f.signals) != 0 {
-				t.Fatal("foreign child signalled")
-			}
-		})
-	}
-}
-func TestCohortRevalidationCancelsWithoutGrantRollback(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	peer := operationPeer{42, 0}
-	if code := c.start(context.Background(), peer, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	p.accounts.(*fakeLocalAccount).value.Groups = []uint32{999}
-	if code := c.chunk(context.Background(), peer, p, carrier, b, 1); code != ErrStale {
-		t.Fatal(code)
-	}
-	if !(*children)[0].stopped {
-		t.Fatal("invalid identity left relay live")
-	}
-	if code := c.chunk(context.Background(), peer, p, carrier, b, 1); code != ErrCanceled {
-		t.Fatal(code)
-	}
-	if c.drain(context.Background(), time.Millisecond) != nil {
-		t.Fatal("drain failed")
-	}
-}
-
-func TestCohortPackageLimitGrantDrainAndReplayRetention(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	peer := operationPeer{42, 0}
-	bindings := []operationBinding{}
-	for n := 0; n < 4; n++ {
-		subject := fmt.Sprintf("%064x", 100+n/2)
-		p.accounts.(*fakeLocalAccount).value.Principal.SubjectRef = subject
-		a, code := p.Resolve(context.Background(), carrier)
-		if code != "" {
-			t.Fatal(code)
-		}
-		b.OperationID = fmt.Sprintf("%064x", 10+n)
-		b.Nonce = fmt.Sprintf("%064x", 20+n)
-		b.GrantID = fmt.Sprintf("%064x", 30+n/2)
-		if code := c.start(context.Background(), peer, p, carrier, a, b); code != "" {
-			t.Fatal(code)
-		}
-		bindings = append(bindings, b)
-	}
-	p.accounts.(*fakeLocalAccount).value.Principal.SubjectRef = fmt.Sprintf("%064x", 500)
-	a, code := p.Resolve(context.Background(), carrier)
-	if code != "" {
-		t.Fatal(code)
-	}
-	b.OperationID = fmt.Sprintf("%064x", 99)
-	b.Nonce = fmt.Sprintf("%064x", 98)
-	if code := c.start(context.Background(), peer, p, carrier, a, b); code != ErrBusy {
-		t.Fatal(code)
-	}
-	if err := c.cancelGrant(context.Background(), bindings[0].GrantID, 1); err != nil {
-		t.Fatal(err)
-	}
-	if len(c.operations) != 2 || !(*children)[0].reaped || !(*children)[1].reaped || (*children)[2].stopped {
-		t.Fatal("per-grant drain affected wrong cohort")
-	}
-	// A completed ID remains burned even when slots become available.
-	if code := c.start(context.Background(), peer, p, carrier, a, bindings[0]); code != ErrReplay {
-		t.Fatal(code)
-	}
-	if err := c.drain(context.Background(), time.Millisecond); err != nil {
-		t.Fatal(err)
-	}
-	q, err := c.proof()
-	if err != nil || q.Reaped != 4 {
-		t.Fatal(q, err)
-	}
-}
-func TestCohortChunkBoundsAndForeignBinding(t *testing.T) {
-	for _, kind := range []string{"zero", "large", "total", "foreign", "helper-dead"} {
-		t.Run(kind, func(t *testing.T) {
-			c, p, carrier, a, b, _ := cohortFixture(t)
-			peer := operationPeer{42, 0}
-			if code := c.start(context.Background(), peer, p, carrier, a, b); code != "" {
-				t.Fatal(code)
-			}
-			n := uint32(1)
-			want := ErrLimit
-			switch kind {
-			case "zero":
-				n = 0
-			case "large":
-				n = MaxChunkBytes + 1
-			case "total":
-				c.operations[b.OperationID].bytes = MaxBoundedBytes
-			case "foreign":
-				b.GrantRevision++
-				want = ErrDenied
-			case "helper-dead":
-				c.helperLive = func() bool { return false }
-				want = ErrDenied
-			}
-			if code := c.chunk(context.Background(), peer, p, carrier, b, n); code != want {
-				t.Fatal(code)
-			}
-		})
-	}
-}
-func TestCohortAdmissionOrdersObserverFence(t *testing.T) {
-	c, p, carrier, a, b, _ := cohortFixture(t)
-	// Fence delivered during native lookup must win before spawn.
-	p.accounts.(*fakeLocalAccount).after = func() { c.gate.fence("native-race") }
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != ErrFenced {
-		t.Fatal(code)
-	}
-}
-
-func TestCohortExpiredOperationStopsRelay(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	peer := operationPeer{42, 0}
-	if code := c.start(context.Background(), peer, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	c.operations[b.OperationID].admittedAt = c.now().Add(-BoundedTimeout)
-	if code := c.chunk(context.Background(), peer, p, carrier, b, 1); code != ErrTimeout || !(*children)[0].stopped {
-		t.Fatal(code)
-	}
-}
-func TestCohortReplayWindowFullDoesNotEvict(t *testing.T) {
-	c, p, carrier, a, b, _ := cohortFixture(t)
-	for n := 0; n < MaxReplayEntries; n++ {
-		c.seen[fmt.Sprintf("op:%064x", n+1000)] = true
-		c.seen[fmt.Sprintf("nonce:%064x", n+2000)] = true
-	}
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != ErrBusy {
-		t.Fatal(code)
-	}
-	if len(c.seen) != 2*MaxReplayEntries {
-		t.Fatal("replay history evicted")
-	}
-}
-func TestCohortPartialBootstrapRetainsChildUntilReaped(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	factory := c.startChild
-	c.startChild = func(a NativeActor, b operationBinding) (operationProcess, error) {
-		child, _ := factory(a, b)
-		return child, ErrDenied
-	}
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != ErrCleanupRequired {
-		t.Fatal(code)
-	}
-	if len(c.operations) != 1 || !(*children)[0].stopped {
-		t.Fatal("partial child lost")
-	}
-	if _, err := c.proof(); err == nil {
-		t.Fatal("unreaped child completed")
-	}
-	if c.drain(context.Background(), time.Millisecond) != nil {
-		t.Fatal("drain failed")
-	}
-	q, err := c.proof()
-	if err != nil || q.Reaped != 1 {
-		t.Fatal(q, err)
-	}
-}
-
-func TestCohortCompletionArtifactRejectsIncompleteProof(t *testing.T) {
-	for _, q := range []CohortCompletion{{Started: 2, Reaped: 1, RelaysStopped: true}, {Started: 2, Reaped: 2}, {Started: 0, Reaped: 0, RelaysStopped: true}, {Started: MaxReplayEntries + 1, Reaped: MaxReplayEntries + 1, RelaysStopped: true}} {
-		c, f := controlFixture(t)
-		r := Record{Inventory: c.Expected, Enabled: true, Lifecycle: testLifecycle("fenced")}
-		record(t, c.Client, r)
-		if err := cleanRuntime(c.Client, true); err != nil {
-			t.Fatal(err)
-		}
-		if completeRecord(c.Client, r.Lifecycle.Epoch, f.current, &q) == nil {
-			t.Fatal("invalid cohort completed", q)
-		}
-	}
-}
-
-func TestCohortCompletionArtifactRoundTrip(t *testing.T) {
-	c, f := controlFixture(t)
-	r := Record{Inventory: c.Expected, Enabled: true, Lifecycle: testLifecycle("fenced")}
-	record(t, c.Client, r)
-	if err := cleanRuntime(c.Client, true); err != nil {
-		t.Fatal(err)
-	}
-	q := CohortCompletion{Started: 2, Reaped: 2, RelaysStopped: true}
-	if err := completeRecord(c.Client, r.Lifecycle.Epoch, f.current, &q); err != nil {
-		t.Fatal(err)
-	}
-	current, err := readRecord(c.StateDir, c.Owner)
-	if err != nil {
-		t.Fatal(err)
-	}
-	proof, err := completionRecord(c.Client, current)
-	if err != nil || proof.Cohort == nil || *proof.Cohort != q {
-		t.Fatal(proof, err)
-	}
-}
-
-func TestCohortIdleOperationDeadlineCancelsBeforeNewLease(t *testing.T) {
-	c, p, carrier, a, b, children := cohortFixture(t)
-	if code := c.start(context.Background(), operationPeer{42, 0}, p, carrier, a, b); code != "" {
-		t.Fatal(code)
-	}
-	admitted := c.now()
-	c.now = func() time.Time { return admitted.Add(BoundedTimeout) }
-	if err := c.poll(); err != nil {
-		t.Fatal(err)
-	}
-	if !(*children)[0].stopped || len((*children)[0].signals) == 0 {
-		t.Fatal("idle operation survived deadline")
-	}
-	if _, err := c.proof(); err == nil {
-		t.Fatal("signal is not quiescence")
-	}
-}