main
1import assert from 'node:assert/strict'
2import { mkdtemp, mkdir, writeFile } from 'node:fs/promises'
3import { tmpdir } from 'node:os'
4import { basename, join } from 'node:path'
5import { test } from 'node:test'
6import { MESSAGE_MAX, VERSION_TAG_MAX } from '../scripts/cd/baseline.ts'
7import { sameSplit, type ListedVersion, type VersionShare } from '../scripts/cd/deploy-plan.ts'
8import { readEvents, RunLog } from '../scripts/cd/log.ts'
9import { DEFAULT_POLICY_PATH, loadPolicy } from '../scripts/cd/policy.ts'
10import { liveSmokeAlreadyPassed, reconcile, unfinishedRunDir, type Reconcile } from '../scripts/cd/reconcile.ts'
11import { isReleaseId, judgeCheckout, releaseFromTag, releaseId, releaseTag, RELEASE_TAG_LENGTH } from '../scripts/cd/release.ts'
13const SHA = '1274f2dd05b83d70f8d421cdcc79628692d848df'
14const WEB = 'be08f0406dab6d5b2d1167e934f7716463a757ed'
15const OTHER_WEB = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
16const NEXT = '8c1af0e2-7b3d-4c1a-9e20-6f0a1b2c3d4e'
17const PREVIOUS = '1aa0bb11-2222-4333-8444-555566667777'
18const PERCENTS = loadPolicy(DEFAULT_POLICY_PATH).policy.steps.map(step => step.percent)
19const REFUSAL = 'deployment is not a canary, a ramp step, or live for this release'
21function release(ply: string, web: string) {
22 const made = releaseId(ply, web)
23 if (!isReleaseId(made)) throw new Error(made.kind)
24 return made
25}
27const RELEASE = release(SHA, WEB)
29type Row = {
30 readonly name: string
31 readonly versionId: string | null
32 readonly tag?: string
33 readonly split: readonly VersionShare[]
34 readonly liveSmokePassed?: boolean
35 readonly want: Reconcile
36}
38function shares(percent: number): VersionShare[] {
39 if (percent === 100) return [{ versionId: NEXT, percentage: 100 }]
40 return [
41 { versionId: PREVIOUS, percentage: 100 - percent },
42 { versionId: NEXT, percentage: percent },
43 ]
44}
46test('reconcile picks the next stage from the live split', () => {
47 const ramp: Row[] = PERCENTS.filter(percent => percent < 100).map(percent => ({
48 name: `at ${percent}%`,
49 versionId: NEXT,
50 split: shares(percent),
51 liveSmokePassed: percent === 25,
52 want: { stage: 'ramp', versionId: NEXT, previous: PREVIOUS, percent },
53 }))
54 const rows: Row[] = [
55 { name: 'no version', versionId: null, split: [{ versionId: PREVIOUS, percentage: 100 }], want: { stage: 'upload' } },
56 { name: 'empty deployment', versionId: null, split: [], want: { stage: 'upload' } },
57 {
58 name: 'tagged version is not in the split',
59 versionId: NEXT,
60 split: [{ versionId: PREVIOUS, percentage: 100 }],
61 want: { stage: 'upload' },
62 },
63 {
64 name: 'at 0%',
65 versionId: NEXT,
66 split: shares(0),
67 want: { stage: 'smoke-canary', versionId: NEXT, previous: PREVIOUS },
68 },
69 ...ramp,
70 {
71 name: 'at 100%',
72 versionId: NEXT,
73 split: shares(100),
74 want: { stage: 'smoke-live', versionId: NEXT, previous: null },
75 },
76 {
77 name: 'same pair at 100% with smoke passed',
78 versionId: NEXT,
79 split: shares(100),
80 liveSmokePassed: true,
81 want: { stage: 'done', versionId: NEXT },
82 },
83 {
84 name: 'same ply sha and a different web sha',
85 versionId: NEXT,
86 tag: releaseTag(release(SHA, OTHER_WEB)),
87 split: shares(100),
88 liveSmokePassed: true,
89 want: { stage: 'upload' },
90 },
91 {
92 name: 'legacy version tagged only with the ply sha',
93 versionId: NEXT,
94 tag: SHA,
95 split: shares(100),
96 liveSmokePassed: true,
97 want: { stage: 'upload' },
98 },
99 {
100 name: 'off the schedule',
101 versionId: NEXT,
102 split: shares(40),
103 want: { stage: 'refuse', reason: REFUSAL },
104 },
105 {
106 name: 'three versions',
107 versionId: NEXT,
108 split: [
109 { versionId: NEXT, percentage: 25 },
110 { versionId: PREVIOUS, percentage: 25 },
111 { versionId: 'aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee', percentage: 50 },
112 ],
113 want: { stage: 'refuse', reason: REFUSAL },
114 },
115 {
116 name: '100% is not alone',
117 versionId: NEXT,
118 split: [
119 { versionId: NEXT, percentage: 100 },
120 { versionId: PREVIOUS, percentage: 0 },
121 ],
122 liveSmokePassed: true,
123 want: { stage: 'refuse', reason: REFUSAL },
124 },
125 ]
126 for (const row of rows) {
127 const versions: ListedVersion[] = row.versionId === null ? [] : [{ id: row.versionId, tag: row.tag ?? releaseTag(RELEASE) }]
128 assert.deepEqual(reconcile({
129 release: RELEASE,
130 versions,
131 split: row.split,
132 liveSmokePassed: row.liveSmokePassed ?? false,
133 rampPercents: PERCENTS,
134 }), row.want, row.name)
135 }
136})
138test('a traffic write is refused when the live split is not the expected prior', () => {
139 const at25 = [
140 { versionId: NEXT, percentage: 25 },
141 { versionId: PREVIOUS, percentage: 75 },
142 ]
143 const at10 = [
144 { versionId: NEXT, percentage: 10 },
145 { versionId: PREVIOUS, percentage: 90 },
146 ]
147 assert.equal(sameSplit(at25, at10), false)
148 assert.equal(sameSplit(at25, at25), true)
149})
151test('re-entry keeps the unfinished run for this sha', async () => {
152 const root = await mkdtemp(join(tmpdir(), 'ply-cd-reconcile-'))
153 const other = join(root, '2026-10-31T21-00-00-000Z')
154 const unfinished = join(root, '2026-10-31T22-00-00-000Z')
155 const finished = join(root, '2026-10-31T23-00-00-000Z')
156 const ledger = join(root, 'ledger.jsonl')
157 const open = async (dir: string, sha: string) => {
158 const log = await RunLog.open(dir, ledger, basename(dir))
159 await log.started({
160 config: { sha, release: { ply: sha, web: WEB } },
161 tools: { node: process.version, cf: 'cf', git: 'git' },
162 plySha: sha,
163 plyWebSha: WEB,
164 host: 'box',
165 release: { ply: sha, web: WEB },
166 })
167 return log
168 }
169 await open(other, 'a'.repeat(40))
170 await open(unfinished, SHA)
171 const done = await open(finished, SHA)
172 await done.finish(0, null)
173 const legacy = join(root, '2026-11-01T00-00-00-000Z')
174 const legacyLog = await RunLog.open(legacy, ledger, basename(legacy))
175 await legacyLog.started({
176 config: { sha: SHA },
177 tools: { node: process.version, cf: 'cf', git: 'git' },
178 plySha: SHA,
179 plyWebSha: 'def',
180 host: 'box',
181 })
182 assert.equal(await unfinishedRunDir(root, RELEASE), unfinished)
183 const resumed = await RunLog.reopen(unfinished, ledger)
184 await resumed.resumed(SHA, { ply: SHA, web: WEB })
185 const events = await readEvents(unfinished)
186 const marker = events.find(event => event.kind === 'lifecycle' && event.payload.event === 'resumed')
187 assert.equal(marker?.run_id, basename(unfinished))
188 assert.equal(marker && marker.kind === 'lifecycle' && marker.payload.event === 'resumed' ? marker.payload.sha : '', SHA)
189})
191test('live smoke already passed is live-smoke.json for this version', async () => {
192 const root = await mkdtemp(join(tmpdir(), 'ply-cd-live-smoke-'))
193 const passed = join(root, '2026-10-31T21-00-00-000Z')
194 const failed = join(root, '2026-10-31T22-00-00-000Z')
195 await mkdir(passed, { recursive: true })
196 await mkdir(failed, { recursive: true })
197 await writeFile(join(passed, 'smoke.json'), JSON.stringify({ version: NEXT, failed: 0 }))
198 await writeFile(join(passed, 'live-smoke.json'), JSON.stringify({ version: NEXT, failed: 0 }))
199 await writeFile(join(failed, 'live-smoke.json'), JSON.stringify({ version: PREVIOUS, failed: 1 }))
200 assert.equal(await liveSmokeAlreadyPassed(root, NEXT), true)
201 assert.equal(await liveSmokeAlreadyPassed(root, PREVIOUS), false)
202})
204test('a release tag is the ply sha and the ply-web sha, and a ply-only tag is not one', () => {
205 const tag = releaseTag(RELEASE)
206 assert.equal(tag, `${SHA}+${WEB}`)
207 assert.equal(tag.length, RELEASE_TAG_LENGTH)
208 assert.ok(RELEASE_TAG_LENGTH <= VERSION_TAG_MAX)
209 assert.ok(`cd canary ${tag}`.length <= MESSAGE_MAX)
210 assert.deepEqual(releaseFromTag(tag), { ply: SHA, web: WEB })
211 assert.equal(releaseFromTag(SHA), null)
212 assert.equal(isReleaseId(releaseId('abc', WEB)), false)
213 assert.equal(isReleaseId(releaseId(SHA, 'abc')), false)
214})
216test('a dirty checkout is not a web sha', () => {
217 assert.deepEqual(judgeCheckout(' M package.json\n', WEB), { ok: false, kind: 'dirty-checkout' })
218 assert.equal(judgeCheckout('', WEB).ok, true)
219 assert.equal(judgeCheckout('', 'abc').ok, false)
220})
Diagnostics4 git calls · 40 ms
CallStatusSizeTime040 ms
discover200152 B4 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200145 B · hit4 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=145 git.response.cache=HIT git.response.duration_ms=4 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=145 git.pkt.payload.max=76 git.ls_refs.count=2 git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020040 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=41349 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=526b305930b8ef382f2d7a1f9c0238730a585921 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=41349 git.pkt.payload.max=41254 git.sideband.band1.bytes=41253 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=61 git.pack.bytes=41253 git.pack.ofs_delta=0 git.pack.ref_delta=0 git.pack.chain.max=0 git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c git.pack.full=61Open pack map
fetch2002.5 KiB · hit34 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=34 git.response.bytes=2538 git.response.cache=HIT git.response.duration_ms=34 git.fetch.wants=bc24fb6e7f8c5144785db26d959356601f417baa git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=2538 git.pkt.payload.max=2517 git.sideband.band1.bytes=2516 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply-web.git
- Ref
- refs/heads/main
- Commit
- 526b305930b8ef382f2d7a1f9c0238730a585921
- cf-ray
- a5e31fb11b229de8
- Request
- 6d189140…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format