carlos / platform Public

Download this file

1	package main
2
3	import (
4	"bytes"
5	"context"
6	"crypto/ed25519"
7	"encoding/base64"
8	"encoding/json"
9	"os"
10	"path/filepath"
11	"strings"
12	"testing"
13	"time"
14
15	"github.com/carlosframework/platform/internal/release"
16	)
17
18	const cliSHA = "e47fcc1e0123456789abcdef0123456789abcdef0123456789abcdef01234567"
19
20	func TestProofKeygenWritesARootOnlyKey(t *testing.T) {
21	path := filepath.Join(t.TempDir(), "proving.key")
22	var out bytes.Buffer
23	if err := proofKeygen(path, &out); err != nil {
24	t.Fatal(err)
25	}
26	fi, err := os.Stat(path)
27	if err != nil || fi.Mode().Perm() != 0o600 {
28	t.Fatalf("key file mode = %v, %v; want 0600", fi.Mode().Perm(), err)
29	}
30	seed, _ := os.ReadFile(path)
31	key, err := release.ParseSigningKey(string(seed), path)
32	if err != nil {
33	t.Fatal(err)
34	}
35	pub := base64.StdEncoding.EncodeToString(key.Public().(ed25519.PublicKey))
36	if !strings.Contains(out.String(), "public key: "+pub+"\n") {
37	t.Fatalf("printed %q, want the key file's public half %s", out.String(), pub)
38	}
39	if err := proofKeygen(path, &out); err == nil || !strings.Contains(err.Error(), "already exists") {
40	t.Fatalf("second keygen = %v, want a refusal to overwrite", err)
41	}
42	}
43
44	func signedCLIProof(t *testing.T) *release.Proof {
45	t.Helper()
46	seed, _, err := release.GenerateKey()
47	if err != nil {
48	t.Fatal(err)
49	}
50	key, err := release.ParseSigningKey(seed, "test")
51	if err != nil {
52	t.Fatal(err)
53	}
54	p, err := release.SignProof(key, release.Proof{App: "console", Platform: "linux-arm64", SHA256: cliSHA,
55	Version: "f4478b15", Prover: "dev", ActiveSince: time.Date(2026, 10, 6, 9, 0, 0, 0, time.UTC),
56	ProvenAt: time.Date(2026, 10, 6, 9, 15, 0, 0, time.UTC)})
57	if err != nil {
58	t.Fatal(err)
59	}
60	return p
61	}
62
63	// get against dev, put against flagship, byte for byte.
64	func TestProofGetThenPutCarriesIt(t *testing.T) {
65	ctx := context.Background()
66	dev, flagship := release.NewDirStore(t.TempDir()), release.NewDirStore(t.TempDir())
67	p := signedCLIProof(t)
68	if err := release.PutProof(ctx, dev, "bab", p); err != nil {
69	t.Fatal(err)
70	}
71	var got bytes.Buffer
72	if err := proofGet(ctx, dev, "bab", "console", cliSHA, "", &got); err != nil {
73	t.Fatalf("proof get: %v", err)
74	}
75	var out bytes.Buffer
76	if err := proofPut(ctx, flagship, "bab", "console", got.Bytes(), &out); err != nil {
77	t.Fatalf("proof put: %v", err)
78	}
79	carried, err := release.GetProof(ctx, flagship, "bab", "console", cliSHA, "dev")
80	if err != nil || carried.Sig != p.Sig {
81	t.Fatalf("carried = %+v, %v", carried, err)
82	}
83	}
84
85	func TestProofGetNotYetNamesTheBake(t *testing.T) {
86	ctx := context.Background()
87	dev := release.NewDirStore(t.TempDir())
88	if err := release.PutProofPending(ctx, dev, "bab", release.ProofPending{App: "console", Platform: "linux-arm64",
89	SHA256: cliSHA, Version: "f4478b15", Prover: "dev",
90	LiveSince: time.Date(2026, 10, 6, 9, 30, 30, 0, time.UTC), After: "15m"}); err != nil {
91	t.Fatal(err)
92	}
93	err := proofGet(ctx, dev, "bab", "console", cliSHA, "", &bytes.Buffer{})
94	want := "not proven yet: " + cliSHA + " has been live on dev since 2026-10-06T09:30:30Z, proven after 15m"
95	if err == nil || err.Error() != want {
96	t.Fatalf("err = %v, want %q", err, want)
97	}
98	err = proofGet(ctx, release.NewDirStore(t.TempDir()), "bab", "console", cliSHA, "", &bytes.Buffer{})
99	if err == nil || !strings.Contains(err.Error(), "has not been seen live") {
100	t.Fatalf("err = %v, want the never-seen text", err)
101	}
102	}
103
104	func TestProofPutRefusesAnotherApp(t *testing.T) {
105	var b bytes.Buffer
106	p := signedCLIProof(t)
107	raw, _ := json.MarshalIndent(p, "", " ")
108	if err := proofPut(context.Background(), release.NewDirStore(t.TempDir()), "bab", "other", raw, &b); err == nil {
109	t.Fatal("put a console proof under another app")
110	}
111	if err := proofPut(context.Background(), release.NewDirStore(t.TempDir()), "bab", "console", []byte(`{"schema":1}`), &b); err == nil {
112	t.Fatal("put a malformed proof")
113	}
114	}
115
116	// Re-running the roll script puts the same proof again: that must succeed.
117	func TestProofPutTwiceIsIdempotent(t *testing.T) {
118	ctx := context.Background()
119	s := release.NewDirStore(t.TempDir())
120	p := signedCLIProof(t)
121	raw, _ := json.MarshalIndent(p, "", " ")
122	for i := 0; i < 2; i++ {
123	if err := proofPut(ctx, s, "bab", "console", raw, &bytes.Buffer{}); err != nil {
124	t.Fatalf("put #%d: %v", i+1, err)
125	}
126	}
127	}
128
129	// A different proof under the same key is refused, and the first one stands.
130	func TestProofPutDifferentProofSameKeyFails(t *testing.T) {
131	ctx := context.Background()
132	s := release.NewDirStore(t.TempDir())
133	p := signedCLIProof(t)
134	raw, _ := json.MarshalIndent(p, "", " ")
135	if err := proofPut(ctx, s, "bab", "console", raw, &bytes.Buffer{}); err != nil {
136	t.Fatal(err)
137	}
138	other := *p
139	other.ProvenAt = other.ProvenAt.Add(time.Minute)
140	raw2, _ := json.MarshalIndent(&other, "", " ")
141	err := proofPut(ctx, s, "bab", "console", raw2, &bytes.Buffer{})
142	if err == nil || !strings.Contains(err.Error(), "already exists with different content") {
143	t.Fatalf("err = %v, want a refusal naming different content", err)
144	}
145	got, gerr := release.GetProof(ctx, s, "bab", "console", cliSHA, "dev")
146	if gerr != nil || got.Sig != p.Sig {
147	t.Fatalf("stored proof changed: %+v, %v", got, gerr)
148	}
149	}
150