mesh-controller/cmd/mesh-controller/first_builds_integration_test.go

//go:build integration

package main

import (
	"context"
	"encoding/json"
	"testing"
	"time"

	"github.com/nats-io/nats.go/jetstream"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	sdkdelivery "git.novox.be/novox/mesh-sdk/go/delivery"
	"github.com/novox/mesh-controller/internal/broker"
	"github.com/novox/mesh-controller/internal/inventory"
	"github.com/novox/mesh-controller/internal/link"
)

// 1146/AC7 on keys (ADR 0501 §3, §6; issue 1851, A5), whole against a real bus and the store, in both orders of the two
// events: mesh-delivery #7 merged on the operator's Approve into a repository the mesh builds nothing from. The forge's
// merge, heard as the controller hears it (SourceMoved), and mesh-delivery's word, published on the subject the
// controller consumes with the router's record of the ask in its bucket, come in either order; each way the module the
// merge commit holds is registered from the builder's done key of it, and nothing asks a build. Without the Approve in
// the record it is not registered. Store-backed: skips without one.
func TestAMergeOnTheApproveIntoANewRepositoryRegistersItsModuleFromItsKey(t *testing.T) {
	const head, commit = "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "0177ea7a00000000"
	for _, c := range []struct {
		what         string
		wordFirst    bool
		approved     bool // the router's record holds the operator's Approve of the merged head
		wantRegister bool
	}{
		{what: "the forge's merge before mesh-delivery's word", approved: true, wantRegister: true},
		{what: "mesh-delivery's word before the forge's merge", wordFirst: true, approved: true, wantRegister: true},
		{what: "a word whose record holds no Approve", wordFirst: true},
	} {
		t.Run(c.what, func(t *testing.T) {
			open := aMesh(t)
			ctx := t.Context()
			inv := open.inventory
			noBuildAsked(t)
			b := aBuilderOnTheBus(t)
			js := b.js
			if err := inv.RegisterModule(ctx, catalogue.Manifest{Module: "operator-channel", Version: "1",
				DefinesSeats: []catalogue.SeatDeclaration{{Name: broker.AsksSeat, Records: []string{"asks"}}}},
				inventory.Source{Repository: "novox/mesh-catalog", Seat: "git", Path: "modules/operator-channel", BuiltFrom: "c0ffee"}); err != nil {
				t.Fatal(err)
			}
			if err := broker.AssertMeshStreams(js); err != nil {
				t.Fatal(err)
			}
			if err := js.EnsureControllerBuckets(); err != nil {
				t.Fatal(err)
			}
			api, err := jetstream.New(js.Conn())
			if err != nil {
				t.Fatal(err)
			}
			records, err := api.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: broker.BucketName("operator-channel", "asks")})
			if err != nil {
				t.Fatal(err)
			}
			a := aDeliveryMergeOf(t, head, map[string]string{"novox/mesh-delivery@a1a1a1a1a1a1": head})
			if c.approved {
				record, _ := json.Marshal(map[string]any{"state": "closed", "ask": a.ask, "warrant": a.warrant})
				if _, err := records.Put(ctx, sdkdelivery.TellerModule+"."+a.merge.AskID, record); err != nil {
					t.Fatal(err)
				}
			}
			// The indexer's value and the builder's done key of the module the merge commit holds.
			fp := fpOf('9')
			manifest := b.indexed(t, "mesh-delivery-view", "1", "novox/mesh-delivery", ".", commit, fp)
			b.built(t, "mesh-delivery-view", "1", fp, manifest, sdkdelivery.BuildDone)

			following := following{open: open}
			server := link.ConnectNats(js, nil, noListener{})
			if err := server.KeepsDeliveryMerges(keepingDeliveryMerges{js: server.JetStream, catalog: theDeliveryClaims, kept: following.resumeFirstBuilds}); err != nil {
				t.Fatal(err)
			}
			if err := broker.AssertServingConsumers(js); err != nil {
				t.Fatal(err)
			}
			serving, stop := context.WithCancel(context.Background())
			done := make(chan struct{})
			go func() { defer close(done); _ = server.Serve(serving) }()
			t.Cleanup(func() { stop(); <-done })

			word := func() {
				t.Helper()
				body, _ := json.Marshal(a.merge)
				if _, err := js.Context().Publish(broker.DeliveryMergedSubjectOf(theDelivery), body); err != nil {
					t.Fatal(err)
				}
				becomes(t, 15*time.Second, "the word being kept", func() bool {
					_, kept, err := keptDeliveryMerge(ctx, "novox", "mesh-delivery", 7, head)
					return err == nil && kept
				})
				time.Sleep(500 * time.Millisecond) // the keeper's hook runs as the word is kept
			}
			forge := func() {
				t.Helper()
				m := link.SourceMoved{Owner: "novox", Repo: "mesh-delivery", Base: "main", HeadSHA: head, Commit: commit, Number: 7,
					MergedAt: time.Now().Add(-time.Second).UTC().Format(time.RFC3339Nano), Paths: []string{"module.json", "main.go"},
					ModuleDirs: []string{"."}, ModuleDirsSaid: true}
				if err := following.SourceMoved(ctx, m); err != nil {
					t.Fatal(err)
				}
			}
			if c.wordFirst {
				word()
				forge()
			} else {
				forge()
				time.Sleep(300 * time.Millisecond)
				if _, known := inventoryHolds(t, inv, "mesh-delivery-view"); known {
					t.Fatal("1146/AC7: registered before mesh-delivery's word was kept")
				}
				word()
			}
			if !c.wantRegister {
				time.Sleep(time.Second)
				if _, known := inventoryHolds(t, inv, "mesh-delivery-view"); known {
					t.Fatal("1146/AC7: a merge whose record holds no Approve registered its module")
				}
				return
			}
			becomes(t, 10*time.Second, "the module registered", func() bool {
				_, known := inventoryHolds(t, inv, "mesh-delivery-view")
				return known
			})
			src, err := inv.SourceOf(ctx, "mesh-delivery-view")
			if err != nil || src.Repository != "novox/mesh-delivery" {
				t.Fatalf("1146/AC7: the module is built from %q (%v)", src.Repository, err)
			}
		})
	}
}

func inventoryHolds(t *testing.T, inv *inventory.Inventory, module string) (inventory.Entry, bool) {
	t.Helper()
	entries, err := inv.Catalogued(t.Context())
	if err != nil {
		t.Fatal(err)
	}
	for _, e := range entries {
		if e.Manifest.Module == module {
			return e, true
		}
	}
	return inventory.Entry{}, false
}