mesh-delivery/modules/mesh-delivery-indexer/internal/index/validation_wait_test.go

package index

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

	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-indexer/takein"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/composer"
)

type askRecorder struct{ asks []buildstep.StepAsk }

func (r *askRecorder) Put(_ context.Context, a buildstep.StepAsk) error {
	r.asks = append(r.asks, a)
	return nil
}

// Design 47 G §713, A-247: a pending revision names its ask on its newest value and resumes on that ask's end; an end of a
// replaced ask is dropped; a run that could not validate is no refusal and never passed; the start asks nothing again while
// the ask is out.
func TestAPendingRevisionWaitsForItsValidation(t *testing.T) {
	ctx := context.Background()
	b := newTakeInBed(t)
	asks := &askRecorder{}
	b.ix.ValidationAsks, b.ix.Inputs, b.ix.Revisions = asks, newMem(), newMemObjects(0)
	// No entry of the revision claims the seat mesh-catalog: the validation could not be asked, so it is failed, said, and
	// nothing is taken in.
	b.arrive(t, 2, b.merge(21, sha('c'), "tree-avahi-3", ""))
	entries := readPending(t, b)
	if len(entries) != 1 || entries[0].Value.Validation == nil || !strings.Contains(entries[0].Value.Validation.Failed, "claims the seat mesh-catalog") || len(asks.asks) != 0 {
		t.Fatalf("pending %+v, asks %d: want m.2 pending with failed and no ask", entries, len(asks.asks))
	}
	if last := b.said[len(b.said)-1]; last.Kind != takein.TakeInPending || last.Failed == "" || last.Refused != "" {
		t.Errorf("said %+v, want take-in.pending naming failed, never a refusal", last)
	}
	if w := PendingWaits(entries); len(w) != 1 || w[0].Validation == nil || w[0].Validation.Try != 1 {
		t.Errorf("indexer_pending %+v, want the validation whole", w)
	}
	// An ask out: the newest value names it; the start asks nothing new while it is out.
	loaded, _, _, _ := b.ix.loadNewest(ctx, entries)
	req, _, err := b.ix.validationRequest(ctx, TrunkBranch, loaded)
	if err != nil {
		t.Fatal(err)
	}
	raw, _ := json.Marshal(req)
	setValidation := func(v takein.Validation) {
		e := readPending(t, b)[0]
		p := e.Value
		p.Validation = &v
		data, _ := encodePending(p)
		if err := b.pending.Update(ctx, e.Key, data, e.Revision); err != nil {
			t.Fatal(err)
		}
	}
	setValidation(takein.Validation{Ask: "mvl0frv18d1957", Input: runDigest(raw), Seq: 2, Try: 2})
	if _, _, err := b.ix.TakeInAtStart(ctx); err != nil || len(asks.asks) != 0 || len(b.keys()) != 1 {
		t.Fatalf("the start: %v, asks %d, pending %v: want it waiting for its ask", err, len(asks.asks), b.keys())
	}
	end := func(ask, outcome, said string, answer any) buildstep.StepEnded {
		out, _ := json.Marshal(answer)
		return buildstep.StepEnded{Ask: ask, ID: ask, Asker: ValidationAsker, Node: "ace", Outcome: outcome, Said: said, Output: string(out)}
	}
	// The answer is the manifest validator's verdict itself, the program's last line (A-254).
	accepted := composer.Verdict{Cases: []composer.CaseVerdict{{Name: "change"}, {Name: "trunk"}}}
	// The end of a replaced ask is dropped, written in the journal.
	if err := b.ix.HearValidationEnded(ctx, end("mvl0frv18d1950", buildstep.OutcomePassed, "", accepted)); err != nil || len(b.keys()) != 1 || !strings.Contains(b.logs.String(), "is dropped") {
		t.Fatalf("a replaced ask's end: %v, pending %v", err, b.keys())
	}
	// could not run: pending with failed, never passed.
	if err := b.ix.HearValidationEnded(ctx, end("mvl0frv18d1957", buildstep.OutcomeCouldNotRun, "no build node", nil)); err != nil {
		t.Fatal(err)
	}
	if v := readPending(t, b)[0].Value.Validation; v == nil || v.Failed != "could not run: no build node" || v.Accepted != 0 {
		t.Fatalf("after could not run: %+v", v)
	}
	// indexer_validate_again (§713): its hand act recorded first, then the next try asked; the answer says the ask's state.
	var recorded []string
	tools := ValidationTools(func(key string, value []byte) (TakeInAsk, error) {
		a, err := DecodeTakeIn(value)
		if err != nil || key != "pending.validate-again."+takein.PendingKey(2) || !a.ValidateAgain {
			t.Fatalf("asked %s %+v %v", key, a, err)
		}
		r := b.ix.ValidateAgainByHand(ctx, a.Pending, a.By, a.Why)
		a.Result = &r
		return a, nil
	}, b.ix.now, func(what, why string) error { recorded = append(recorded, what); return nil })
	if len(tools) != 1 || tools[0].Name != ValidateAgainTool {
		t.Fatalf("tools = %v", tools)
	}
	if _, err := tools[0].Run(map[string]any{"key": takein.PendingKey(2)}); err == nil || len(recorded) != 0 {
		t.Fatalf("asked again with no why: %v, %v", err, recorded)
	}
	got, err := tools[0].Run(map[string]any{"key": takein.PendingKey(2), "why": "the build node is back"})
	if v := readPending(t, b)[0].Value.Validation; err != nil || len(recorded) != 1 || v == nil || v.Try != 3 || v.Failed == "could not run: no build node" ||
		!strings.Contains(got.(*TakenIn).Answer, "try 3") {
		t.Fatalf("asked again: %v, recorded %v, validation %+v, answer %+v: want the try after 2 asked", err, recorded, v, got)
	}
	setValidation(takein.Validation{Ask: "mvl0frv18d1959", Input: runDigest(raw), Seq: 2, Try: 3})
	if r := b.ix.ValidateAgainByHand(ctx, takein.PendingKey(2), "lead", "again"); r.Stored || !strings.Contains(r.Answer, "is out") || readPending(t, b)[0].Value.Validation.Try != 3 {
		t.Fatalf("an ask out was asked again: %+v", r)
	}
	// Asked again (by hand or by a later merge) and accepted: the revision is taken in, and its keys go.
	setValidation(takein.Validation{Ask: "mvl0frv18d1958", Input: runDigest(raw), Seq: 2, Try: 3})
	if err := b.ix.HearValidationEnded(ctx, end("mvl0frv18d1958", buildstep.OutcomePassed, "", accepted)); err != nil {
		t.Fatal(err)
	}
	if len(b.keys()) != 0 || b.commit(t, "avahi") != sha('c') {
		t.Fatalf("accepted: pending %v %+v, avahi at %s: want it taken in\n%s", b.keys(), readPending(t, b)[0].Value, b.commit(t, "avahi"), b.logs.String())
	}
}