package check import ( "context" "encoding/json" "errors" "strings" "sync" "testing" "time" "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient" nec "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient" ne "git.novox.be/novox/mesh-contracts/go/seats/nodeengine" "git.novox.be/novox/mesh-delivery/contracts/go/clients/meshdeliverycheckerclient" "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshcatalog" "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshdeliverychecker" "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshwants" "git.novox.be/novox/mesh-delivery/sdk/buildstep" "git.novox.be/novox/mesh-delivery/sdk/composer" ) // fakeEngines answers compose-candidate by node from memory; a node it holds no answer for never answers. type fakeEngines struct { mu sync.Mutex answers map[string]ne.ComposeCandidateAnswer errs map[string]error asked map[string]ne.ComposeCandidateInput } func (f *fakeEngines) ComposeCandidate(ctx context.Context, node string, ask ne.ComposeCandidateInput) (ne.ComposeCandidateAnswer, error) { f.mu.Lock() if f.asked == nil { f.asked = map[string]ne.ComposeCandidateInput{} } f.asked[node] = ask a, ok := f.answers[node] err := f.errs[node] f.mu.Unlock() if err != nil { return ne.ComposeCandidateAnswer{}, err } if !ok { <-ctx.Done() return ne.ComposeCandidateAnswer{}, ctx.Err() } return a, nil } // fakeSandbox answers a compose job with a verdict, recording the job. type fakeSandbox struct { mu sync.Mutex jobs []buildstep.ComposeJob v func(node string) composer.Verdict err error } func (f *fakeSandbox) Compose(_ context.Context, job buildstep.ComposeJob) (composer.Verdict, error) { var req composer.Request if err := json.Unmarshal(job.Request, &req); err != nil { return composer.Verdict{}, err } f.mu.Lock() f.jobs = append(f.jobs, job) f.mu.Unlock() if f.err != nil { return composer.Verdict{}, f.err } return f.v(req.Machines[0]), nil } type digests map[string]string func (d digests) ManifestDigests() map[string]string { return d } // ADR 0593 §7, §9 (D12, G1, G2): the checker asks every placed node's engine in parallel and makes the composition from // their answers: a refusal fails it naming the node and each module; a node that does not answer within the bound, // answers unready or cannot be asked is named "not composed on that node: no answer" and the check passes with that // warning, decided by the verdict and never by its words; a group with a node-engine member is composed by the composer // built at that member's head, over the input each node's engine composed from. func TestTheCompositionIsMadeFromTheEnginesAnswers(t *testing.T) { composed := func(node string) ne.ComposeCandidateAnswer { return ne.ComposeCandidateAnswer{Node: node, Verdict: nec.Composed, Modules: []ne.Module{{Module: "web", State: nec.ModuleComposed, Digest: "sha256:" + strings.Repeat("a", 64)}}, Own: ne.Module{Module: nec.Own, State: nec.ModuleComposed, Digest: "sha256:" + strings.Repeat("b", 64)}} } cs := caseOf(t, pullOf(repoA, 7, head1)) key, _ := nodeengineclient.CompositionKey(cs.Group, cs.HeadsHash) compose := func(e *fakeEngines, nodes ...string) meshwants.CompositionsByGroupHeadsValue { t.Helper() ec := EngineCompositions{Asker: e, Placed: func() ([]string, error) { return nodes, nil }, Bound: 50 * time.Millisecond, Composer: func() string { return strings.Repeat("7", 40) }} v, err := ec.Compose(context.Background(), cs) if err != nil { t.Fatal(err) } return v } t.Run("one node refusing fails the composition, naming the node and the module", func(t *testing.T) { refusing := composed("laptop") refusing.Verdict = nec.Refused refusing.Modules = []ne.Module{{Module: "web", State: nec.ModuleRefused, Words: "a required value is unset"}, {Module: "mail", State: nec.ModuleHeld, Words: "held as today"}} e := &fakeEngines{answers: map[string]ne.ComposeCandidateAnswer{"anchor": composed("anchor"), "laptop": refusing}} v := compose(e, "anchor", "laptop") if v.State != meshdeliverycheckerclient.CompositionFail || v.Machine != "laptop" || !strings.Contains(v.Words, "not composed on laptop: web: a required value is unset") || strings.Contains(v.Words, "mail") || len(v.Machines) != 2 { t.Errorf("verdict = %+v", v) } if e.asked["anchor"].Candidate != key || e.asked["laptop"].Input { t.Errorf("asked %+v, want the check's candidate %s and no input", e.asked, key) } var ver meshdeliverychecker.VerdictsByGroupHeadsValue withComposition(&ver, v) if ver.State != meshdeliverycheckerclient.VerdictFail || ver.Failed.Machine != "laptop" { t.Errorf("the check's verdict = %+v", ver) } }) t.Run("a silent, unready or unreachable node is no answer, and the check passes naming it", func(t *testing.T) { unready := ne.ComposeCandidateAnswer{Node: "g14", Verdict: nec.Unready, Refused: "a module refused it"} e := &fakeEngines{answers: map[string]ne.ComposeCandidateAnswer{"anchor": composed("anchor"), "g14": unready}, errs: map[string]error{"ace": errors.New("no responders")}} began := time.Now() v := compose(e, "anchor", "laptop", "g14", "ace") if took := time.Since(began); took > 2*time.Second { t.Errorf("the nodes were not asked in parallel within the bound: %s", took) } if v.State != meshdeliverycheckerclient.CompositionPass || v.Sdk != strings.Repeat("7", 40) || len(v.Machines) != 1 { t.Fatalf("verdict = %+v", v) } for _, node := range []string{"ace", "g14", "laptop"} { if !strings.Contains(strings.Join(v.Warnings, "; "), node+": "+nec.NoAnswer) { t.Errorf("%s is not named: %v", node, v.Warnings) } } var ver meshdeliverychecker.VerdictsByGroupHeadsValue ver.State = meshdeliverycheckerclient.VerdictPass withComposition(&ver, v) if ver.State != meshdeliverycheckerclient.VerdictPass || !strings.Contains(composition(ver.Composition, 0, false), "laptop: "+nec.NoAnswer) { t.Errorf("the line = %q", composition(ver.Composition, 0, false)) } }) t.Run("a node-engine member is composed by the composer at its head over each node's input", func(t *testing.T) { c, err := meshcatalog.DecodeCandidatesByGroupValue(candidateOf(t, "feat/x", pullOf(nodeEngineRepo, 3, head2), pullOf(repoA, 7, head1))) if err != nil { t.Fatal(err) } host := CaseOf(c, map[string]string{repoA: trunkA, nodeEngineRepo: trunkA}) withInput := composed("anchor") withInput.Input = map[string]any{"nodes": []any{map[string]any{"name": "anchor"}}} e := &fakeEngines{answers: map[string]ne.ComposeCandidateAnswer{"anchor": withInput}} sb := &fakeSandbox{v: func(node string) composer.Verdict { return composer.Verdict{V: composer.Version, Cases: []composer.CaseVerdict{{Name: "change", Machines: map[string]composer.Machine{node: {Composes: false, Reason: "the new composer refuses it"}}}}} }} ec := EngineCompositions{Asker: e, Placed: func() ([]string, error) { return []string{"anchor"}, nil }, Bound: time.Second, Sandbox: sb, Manifests: digests{"web": "sha256:" + strings.Repeat("c", 64)}} v, err := ec.Compose(context.Background(), host) if err != nil { t.Fatal(err) } if !e.asked["anchor"].Input || len(sb.jobs) != 1 { t.Fatalf("asked %+v, jobs %+v: want the input asked and one job", e.asked, sb.jobs) } job := sb.jobs[0] var req composer.Request _ = json.Unmarshal(job.Request, &req) if job.Fetch.Repository != nodeEngineRepo || job.Fetch.Commit != head2 || job.Package != composer.Package || string(req.Input) != `{"nodes":[{"name":"anchor"}]}` || req.Cases[0].Manifests["web"].Digest == "" { t.Errorf("job = %+v, request %+v", job, req) } if v.State != meshdeliverycheckerclient.CompositionFail || v.Sdk != head2 || !strings.Contains(v.Words, "the new composer refuses it") { t.Errorf("verdict = %+v", v) } // ADR 0593 §9 (ADR 0601 §4's kind): a node the composer did not judge is named as no answer with its words, by the // contract's field, and the check passes; words in Reason alone are no such mark. sb.err = nil for _, row := range []struct { m composer.Machine pass bool }{ {composer.Machine{NotJudged: "its node-engine sends no running state for web"}, true}, {composer.Machine{Reason: "not judged: its node-engine sends no running state for web"}, false}, } { sb.v = func(node string) composer.Verdict { return composer.Verdict{V: composer.Version, Cases: []composer.CaseVerdict{{Name: "change", Machines: map[string]composer.Machine{node: row.m}}}} } v, err = ec.Compose(context.Background(), host) named := len(v.Warnings) == 1 && strings.Contains(v.Warnings[0], "anchor: "+nec.NoAnswer+" (its node-engine sends no running state for web)") if err != nil || (v.State == meshdeliverycheckerclient.CompositionPass) != row.pass || named != row.pass { t.Errorf("%+v: verdict %+v, %v", row.m, v, err) } } // Review finding 3 (ADR 0593 §9 lets only a node that does not answer pass): a composer at the head that cannot // run fails the composition, naming the head, never passing as a silent node. sb.err = errors.New("the build of mesh-compose failed") v, err = ec.Compose(context.Background(), host) if err != nil || v.State != meshdeliverycheckerclient.CompositionFail || !strings.Contains(v.Words, head2) || !strings.Contains(v.Words, "the build of mesh-compose failed") || len(v.Warnings) != 0 { t.Errorf("a composer that cannot run: %+v, %v", v, err) } }) // Review finding 4: assignments that cannot be read is no mesh with no node: the composition is not made, said. t.Run("an unreadable assignments makes no composition", func(t *testing.T) { ec := EngineCompositions{Asker: &fakeEngines{}, Placed: func() ([]string, error) { return nil, errors.New("no such bucket") }} if _, err := ec.Compose(context.Background(), cs); err == nil || !strings.Contains(err.Error(), "no such bucket") { t.Errorf("an unreadable assignments: %v", err) } b := newBench(t) b.ex.Compositions = ec v := b.judge(t, cs).Verdict if v.Composition == nil || v.Composition.State != meshdeliverycheckerclient.CompositionNotRun || !strings.Contains(v.Composition.Words, "no such bucket") { t.Errorf("the verdict's composition = %+v", v.Composition) } }) }