161 lines
7.0 KiB
Go
161 lines
7.0 KiB
Go
package delivery
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The new form's inputs (novox/hq ADR 0429 clause 5 as ADR 0437 clause 5 changed it, ADR 0405 clause 7). The base and
|
|
// builder values are module fingerprints in the new form; a lock is the caller's hash of a lock file, which this
|
|
// function only enters (its form is the builder's to settle; the values here are stand-in tokens); the toolchain is a
|
|
// language, the installed toolchain's version and the build module's recipe version.
|
|
func inputs2() SourceInputs2 {
|
|
return SourceInputs2{
|
|
Module: "mesh-mail",
|
|
Tree: "t-module",
|
|
Bases: []string{SourcePrefix2 + strings.Repeat("a", 64), SourcePrefix2 + strings.Repeat("b", 64)},
|
|
Builder: SourcePrefix2 + strings.Repeat("c", 64),
|
|
Contexts: map[string]string{"mail": "t-root", "tool": "t-root2"},
|
|
Locks: map[string]string{"mail": "sha256:1111", "tool": "sha256:2222"},
|
|
Toolchains: map[string]Toolchain2{
|
|
"mail": {Language: "go", Version: "1.26.0", Recipe: "3"},
|
|
"tool": {Language: "typescript", Version: "5.9.2", Recipe: "1"},
|
|
},
|
|
}
|
|
}
|
|
|
|
func mustFP2(t *testing.T, in SourceInputs2) string {
|
|
t.Helper()
|
|
fp, none := SourceFingerprint2(in)
|
|
if fp == "" || none != "" {
|
|
t.Fatalf("fingerprint = %q, none = %q", fp, none)
|
|
}
|
|
return fp
|
|
}
|
|
|
|
// 1356/AC1: a fixed input has the fingerprint the test fixes, with the new prefix. The hex was computed from the function and checked against an independent sha256 of the lines;
|
|
// it is pinned here, so a change of the lines is a change of every fingerprint, and shows.
|
|
func TestFingerprint2Vector(t *testing.T) {
|
|
const want = "src2:56b6f2f6ffc1767225e0b277ab78539521e9a9fbaadfe4ec158d2fddee1d63ef"
|
|
if got := mustFP2(t, inputs2()); got != want {
|
|
t.Errorf("fingerprint = %s, want %s", got, want)
|
|
}
|
|
if SourcePrefix2 != "src2:" || SourcePrefix == SourcePrefix2 {
|
|
t.Errorf("the new prefix is %q", SourcePrefix2)
|
|
}
|
|
}
|
|
|
|
// 1356/AC2: each input on its own changes the fingerprint.
|
|
func TestFingerprint2Changes(t *testing.T) {
|
|
want := mustFP2(t, inputs2())
|
|
for name, f := range map[string]func(*SourceInputs2){
|
|
"module": func(in *SourceInputs2) { in.Module = "other" },
|
|
"tree": func(in *SourceInputs2) { in.Tree = "t-other" },
|
|
"a base": func(in *SourceInputs2) { in.Bases[0] = SourcePrefix2 + strings.Repeat("d", 64) },
|
|
"a base added": func(in *SourceInputs2) { in.Bases = append(in.Bases, SourcePrefix2+strings.Repeat("e", 64)) },
|
|
"the builder": func(in *SourceInputs2) { in.Builder = SourcePrefix2 + strings.Repeat("f", 64) },
|
|
"a lock": func(in *SourceInputs2) { in.Locks["mail"] = "sha256:changed" },
|
|
"a lock added": func(in *SourceInputs2) { in.Locks["extra"] = "sha256:3333" },
|
|
"a toolchain": func(in *SourceInputs2) { in.Toolchains["mail"] = Toolchain2{"go", "1.26.1", "3"} },
|
|
"a toolchain lang": func(in *SourceInputs2) { in.Toolchains["mail"] = Toolchain2{"typescript", "1.26.0", "3"} },
|
|
"a recipe": func(in *SourceInputs2) { in.Toolchains["mail"] = Toolchain2{"go", "1.26.0", "4"} },
|
|
"a context": func(in *SourceInputs2) { in.Contexts["mail"] = "t-changed" },
|
|
"a context added": func(in *SourceInputs2) { in.Contexts["extra"] = "t-root" },
|
|
"a toolchain added": func(in *SourceInputs2) { in.Toolchains["extra"] = Toolchain2{"go", "1.26.0", "3"} },
|
|
} {
|
|
in := inputs2()
|
|
f(&in)
|
|
if got := mustFP2(t, in); got == want {
|
|
t.Errorf("a changed %s keeps the fingerprint", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1356/AC3: a base given twice, and maps in any order, give the same fingerprint.
|
|
func TestFingerprint2OrderAndDuplicates(t *testing.T) {
|
|
want := mustFP2(t, inputs2())
|
|
in := inputs2()
|
|
in.Bases = []string{in.Bases[1], in.Bases[0]}
|
|
if got := mustFP2(t, in); got != want {
|
|
t.Errorf("the order of bases changes it: %s", got)
|
|
}
|
|
in = inputs2()
|
|
in.Bases = append(in.Bases, in.Bases[0], in.Bases[1])
|
|
if got := mustFP2(t, in); got != want {
|
|
t.Errorf("a base given twice changes it: %s", got)
|
|
}
|
|
for i := 0; i < 20; i++ {
|
|
in = inputs2()
|
|
in.Contexts, in.Locks, in.Toolchains = map[string]string{}, map[string]string{}, map[string]Toolchain2{}
|
|
for _, k := range []string{"tool", "mail"} {
|
|
in.Contexts[k] = inputs2().Contexts[k]
|
|
in.Locks[k] = inputs2().Locks[k]
|
|
in.Toolchains[k] = inputs2().Toolchains[k]
|
|
}
|
|
if got := mustFP2(t, in); got != want {
|
|
t.Fatalf("map order changes it: %s", got)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1356/AC4: an artifact that resolves packages when built, with no lock, gives no fingerprint and the reason "no lock";
|
|
// a module with no tree gets none with today's reason, and the reason the source is unpinned stands over both.
|
|
func TestFingerprint2None(t *testing.T) {
|
|
in := inputs2()
|
|
in.Locks["mail"] = ""
|
|
if fp, none := SourceFingerprint2(in); fp != "" || none != "no lock" {
|
|
t.Errorf("no lock: fp = %q, none = %q", fp, none)
|
|
}
|
|
in = inputs2()
|
|
in.Tree = ""
|
|
if fp, none := SourceFingerprint2(in); fp != "" || none != "no tree" {
|
|
t.Errorf("no tree: fp = %q, none = %q", fp, none)
|
|
}
|
|
in = inputs2()
|
|
in.Tree, in.Unpinned = "", "a context is a Go program's build source"
|
|
if _, none := SourceFingerprint2(in); none != in.Unpinned {
|
|
t.Errorf("the reason for unpinned stands over no tree: %q", none)
|
|
}
|
|
}
|
|
|
|
// 1356/AC5: src1 is unchanged by the new form; its vectors in fingerprint_test.go run unchanged. This pins that the
|
|
// two forms do not collide for equal module and tree, and that src1 keeps its prefix.
|
|
func TestSource1StaysSource1(t *testing.T) {
|
|
if SourcePrefix != "src1:" {
|
|
t.Fatalf("src1's prefix is %q", SourcePrefix)
|
|
}
|
|
fp1, _ := SourceFingerprint(SourceInputs{Module: "m", Tree: "t"})
|
|
fp2, _ := SourceFingerprint2(SourceInputs2{Module: "m", Tree: "t"})
|
|
if fp1 == "" || fp2 == "" || strings.TrimPrefix(fp1, SourcePrefix) == strings.TrimPrefix(fp2, SourcePrefix2) {
|
|
t.Errorf("src1 %q and src2 %q", fp1, fp2)
|
|
}
|
|
}
|
|
|
|
// 1356/AC6: the key part holds only bus key characters and parsing gives the fingerprint back; a src1 or malformed
|
|
// value is refused, naming it.
|
|
func TestFingerprintKeyPart(t *testing.T) {
|
|
fp := mustFP2(t, inputs2())
|
|
part, err := FingerprintKeyPart(fp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(part) != 64 || strings.Trim(part, "0123456789abcdef") != "" || !nameOK.MatchString(part) {
|
|
t.Errorf("key part %q is not 64 lowercase hex characters a key allows", part)
|
|
}
|
|
back, err := ParseFingerprintKeyPart(part)
|
|
if err != nil || back != fp {
|
|
t.Errorf("parse(%q) = %q, %v; want %q", part, back, err, fp)
|
|
}
|
|
src1, _ := SourceFingerprint(SourceInputs{Module: "m", Tree: "t"})
|
|
for _, bad := range []string{src1, "src2:", "src2:xyz", "", "src2:" + strings.Repeat("A", 64), "src2:" + strings.Repeat("a", 63)} {
|
|
if _, err := FingerprintKeyPart(bad); err == nil || !strings.Contains(err.Error(), "\""+bad+"\"") {
|
|
t.Errorf("FingerprintKeyPart(%q) = %v, want a refusal naming it", bad, err)
|
|
}
|
|
}
|
|
for _, bad := range []string{src1, "src2:" + strings.Repeat("a", 64), strings.Repeat("a", 63), strings.Repeat("A", 64), "", "zz"} {
|
|
if _, err := ParseFingerprintKeyPart(bad); err == nil || !strings.Contains(err.Error(), "\""+bad+"\"") {
|
|
t.Errorf("ParseFingerprintKeyPart(%q) = %v, want a refusal naming it", bad, err)
|
|
}
|
|
}
|
|
}
|