81 lines
2.6 KiB
Go
81 lines
2.6 KiB
Go
package buildstep
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// The toolchains value and key are the layout all three node-build seats generate: each seat's fixture of the state
|
|
// reads strictly into Toolchain, and the key is the seat's key form <node>.<language>.
|
|
func TestTheToolchainsValueAndKeyAreTheSeatsLayout(t *testing.T) {
|
|
read := 0
|
|
for _, seat := range []string{"node-build-go", "node-build-image", "node-build-node"} {
|
|
raw, err := os.ReadFile(filepath.Join("..", "..", "contracts", "seats", seat, "fixtures", "states.json"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var fixtures []struct {
|
|
Of string `json:"of"`
|
|
Given json.RawMessage `json:"given"`
|
|
}
|
|
if err := json.Unmarshal(raw, &fixtures); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, f := range fixtures {
|
|
if f.Of != "state:toolchains/<node>.<language>" {
|
|
continue
|
|
}
|
|
if back, err := DecodeToolchain(f.Given); err != nil || back.Version == "" {
|
|
t.Errorf("%s: the fixture reads as %+v, %v", seat, back, err)
|
|
}
|
|
if _, err := EncodeToolchain(mustToolchain(t, f.Given)); err != nil {
|
|
t.Errorf("%s: %v", seat, err)
|
|
}
|
|
dec := json.NewDecoder(bytes.NewReader(f.Given))
|
|
dec.DisallowUnknownFields()
|
|
if err := dec.Decode(&Toolchain{}); err != nil {
|
|
t.Errorf("%s: %v", seat, err)
|
|
}
|
|
read++
|
|
}
|
|
}
|
|
if read != 3 {
|
|
t.Errorf("%d toolchain fixtures read, want 3", read)
|
|
}
|
|
raw, err := EncodeToolchain(Toolchain{Language: "go", Version: "go1.27.1", Recipe: "3", At: time.Date(2026, 11, 5, 10, 0, 0, 0, time.UTC)})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if back, err := DecodeToolchain(raw); err != nil || back.Version != "go1.27.1" || back.At.IsZero() {
|
|
t.Errorf("the value reads back as %+v, %v", back, err)
|
|
}
|
|
if key, err := ToolchainKey("ace", "typescript"); err != nil || key != "ace.typescript" {
|
|
t.Errorf("key %q, %v", key, err)
|
|
}
|
|
for _, bad := range [][2]string{{"", "go"}, {"a.b", "go"}, {"ace", "rust"}} {
|
|
if _, err := ToolchainKey(bad[0], bad[1]); err == nil {
|
|
t.Errorf("the key of %v was made", bad)
|
|
}
|
|
}
|
|
if _, err := EncodeToolchain(Toolchain{Language: "go", Version: "go1.27"}); err == nil {
|
|
t.Error("a toolchain without its recipe was written")
|
|
}
|
|
if _, err := DecodeToolchain([]byte(`{"v":1,"language":"go","version":"x","recipe":"1","extra":1}`)); err == nil || !strings.Contains(err.Error(), "extra") {
|
|
t.Errorf("a field the layout lacks was read: %v", err)
|
|
}
|
|
}
|
|
|
|
func mustToolchain(t *testing.T, raw []byte) Toolchain {
|
|
t.Helper()
|
|
var tc Toolchain
|
|
if err := json.Unmarshal(raw, &tc); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return tc
|
|
}
|