75 lines
3.1 KiB
Go
75 lines
3.1 KiB
Go
package delivery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
)
|
|
|
|
// A composition that carries its plan or its refusal (ADR 0593 §6): each round-trips, and a reader refuses what it could
|
|
// not take, naming it. (compose-candidate's ask and answer are node-engine's client's, mesh-contracts
|
|
// go/clients/nodeengineclient, ADR 0627 §1.)
|
|
func TestComposeCandidateAndComposedPlanRoundTripAndRefuse(t *testing.T) {
|
|
fp := "src2:" + strings.Repeat("a", 64)
|
|
planned := Composed{Node: "ace", Module: "netcheck", FP: fp, Resources: []json.RawMessage{},
|
|
Plan: &catalogue.Plan{Files: []catalogue.PlanFile{}}}
|
|
raw, err := EncodeComposed(planned)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c, err := DecodeComposed(raw)
|
|
if err != nil || c.Plan == nil {
|
|
t.Fatalf("a composition's plan did not round-trip: %v, %+v", err, c)
|
|
}
|
|
d1, _ := ComposedDigestOf(planned)
|
|
d0, _ := ComposedDigestOf(Composed{Node: "ace", Module: "netcheck", FP: fp, Resources: []json.RawMessage{}})
|
|
if d1 == "" || d1 != d0 {
|
|
t.Error("the digest moves with the plan: it is the resources' alone")
|
|
}
|
|
if SameComposed(planned, Composed{Node: "ace", Module: "netcheck", FP: fp, Resources: []json.RawMessage{}}) {
|
|
t.Error("a plan change is not a new composition value")
|
|
}
|
|
signed := strings.Replace(string(raw), `"resources"`, `"signature":{"signer":"x","sig":"y"},"resources"`, 1)
|
|
if c, err := DecodeComposed([]byte(signed)); err != nil || c.Node != "ace" {
|
|
t.Fatalf("a composition the ended controller signed does not decode: %v", err)
|
|
}
|
|
if strings.Contains(string(raw), "signature") {
|
|
t.Error("a composition is written with a signature")
|
|
}
|
|
refused := Composed{Node: "ace", Module: "netcheck", FP: fp, Refused: "the setting domain has no value"}
|
|
if raw, err = EncodeComposed(refused); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if c, err := DecodeComposed(raw); err != nil || c.Refused != refused.Refused {
|
|
t.Fatalf("a refused composition did not round-trip: %v", err)
|
|
}
|
|
if _, err := ComposedDigestOf(refused); err == nil {
|
|
t.Error("a refused composition has a digest")
|
|
}
|
|
refused.Data = true
|
|
if _, err := EncodeComposed(refused); err == nil {
|
|
t.Error("a refused composition holding data was encoded")
|
|
}
|
|
if _, err := EncodeComposed(Composed{Node: "ace", Resources: []json.RawMessage{}, Refused: "x"}); err == nil {
|
|
t.Error("the node's own composition carried a refusal")
|
|
}
|
|
}
|
|
|
|
// A kept import form is set only with imports, and in the fingerprint's form (ADR 0593 §4).
|
|
func TestAKeptImportFormNeedsImports(t *testing.T) {
|
|
form := SourcePrefix2 + strings.Repeat("b", 64)
|
|
in := KeptInputs2{Tree: "t", Imports: []string{"git.novox.be/novox/mesh-sdk/go"}, ImportForm: form}
|
|
m := Module{FP2: form, Manifest: strings.Repeat("c", 64), Inputs2: &in, Repository: "novox/x", Commit: "c"}
|
|
if err := m.check(); err != nil && strings.Contains(err.Error(), "import form") {
|
|
t.Fatalf("a good import form refused: %v", err)
|
|
}
|
|
for _, bad := range []KeptInputs2{{Tree: "t", ImportForm: form}, {Tree: "t", Imports: in.Imports, ImportForm: "src2:short"}} {
|
|
m.Inputs2 = &bad
|
|
if err := m.check(); err == nil || !strings.Contains(err.Error(), "import form") {
|
|
t.Errorf("%+v: %v", bad, err)
|
|
}
|
|
}
|
|
}
|