| 1 | const assert = require("node:assert/strict"); |
| 2 | const path = require("node:path"); |
| 3 | const test = require("node:test"); |
| 4 | const os = require("os"); |
| 5 | |
| 6 | const ARTIFACTS_PATH = path.join(__dirname, "..", "scripts", "artifacts.js"); |
| 7 | |
| 8 | function withMockedOs(platform, arch, fn) { |
| 9 | const origPlatform = os.platform; |
| 10 | const origArch = os.arch; |
| 11 | os.platform = () => platform; |
| 12 | os.arch = () => arch; |
| 13 | delete require.cache[ARTIFACTS_PATH]; |
| 14 | try { |
| 15 | return fn(); |
| 16 | } finally { |
| 17 | os.platform = origPlatform; |
| 18 | os.arch = origArch; |
| 19 | delete require.cache[ARTIFACTS_PATH]; |
| 20 | } |
| 21 | } |
| 22 | |
| 23 | test("openharmony x64 resolves to linux x64 binaries", () => { |
| 24 | withMockedOs("openharmony", "x64", () => { |
| 25 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 26 | const result = detectBinaryNames(); |
| 27 | assert.equal(result.codewhale, "codewhale-linux-x64"); |
| 28 | assert.equal(result.codew, "codew-linux-x64"); |
| 29 | assert.equal(result.tui, undefined); |
| 30 | }); |
| 31 | }); |
| 32 | |
| 33 | test("openharmony arm64 resolves to linux arm64 binaries", () => { |
| 34 | withMockedOs("openharmony", "arm64", () => { |
| 35 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 36 | const result = detectBinaryNames(); |
| 37 | assert.equal(result.codewhale, "codewhale-linux-arm64"); |
| 38 | assert.equal(result.codew, "codew-linux-arm64"); |
| 39 | }); |
| 40 | }); |
| 41 | |
| 42 | test("android arm64 resolves to Termux-native Android assets", () => { |
| 43 | withMockedOs("android", "arm64", () => { |
| 44 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 45 | const result = detectBinaryNames(); |
| 46 | assert.equal(result.codewhale, "codewhale-android-arm64"); |
| 47 | assert.equal(result.codew, "codew-android-arm64"); |
| 48 | }); |
| 49 | }); |
| 50 | |
| 51 | test("genuinely unsupported platform throws with raw platform name", () => { |
| 52 | withMockedOs("freebsd", "x64", () => { |
| 53 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 54 | assert.throws( |
| 55 | () => detectBinaryNames(), |
| 56 | (err) => { |
| 57 | assert.match(err.message, /Unsupported platform: freebsd/); |
| 58 | return true; |
| 59 | }, |
| 60 | ); |
| 61 | }); |
| 62 | }); |
| 63 | |
| 64 | test("known platforms are unaffected by alias map", () => { |
| 65 | for (const [platform, arch, expectedCodeWhale] of [ |
| 66 | ["linux", "x64", "codewhale-linux-x64"], |
| 67 | ["darwin", "arm64", "codewhale-macos-arm64"], |
| 68 | ["win32", "x64", "codewhale-windows-x64.exe"], |
| 69 | ["win32", "arm64", "codewhale-windows-arm64.exe"], |
| 70 | ]) { |
| 71 | withMockedOs(platform, arch, () => { |
| 72 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 73 | const result = detectBinaryNames(); |
| 74 | assert.equal(result.codewhale, expectedCodeWhale); |
| 75 | }); |
| 76 | } |
| 77 | }); |
| 78 | |
| 79 | test("Windows arm64 resolves the complete native binary family", () => { |
| 80 | withMockedOs("win32", "arm64", () => { |
| 81 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 82 | assert.deepEqual(detectBinaryNames(), { |
| 83 | platform: "win32", |
| 84 | arch: "arm64", |
| 85 | codewhale: "codewhale-windows-arm64.exe", |
| 86 | codew: "codew-windows-arm64.exe", |
| 87 | }); |
| 88 | }); |
| 89 | }); |
| 90 | |
| 91 | test("linux riscv64 reports the temporary upstream binding blocker", () => { |
| 92 | withMockedOs("linux", "riscv64", () => { |
| 93 | const { detectBinaryNames } = require(ARTIFACTS_PATH); |
| 94 | assert.throws( |
| 95 | () => detectBinaryNames(), |
| 96 | (err) => { |
| 97 | assert.match(err.message, /Unsupported architecture: riscv64 on platform linux/); |
| 98 | assert.match(err.message, /rquickjs-sys/); |
| 99 | assert.match(err.message, /riscv64gc-unknown-linux-gnu/); |
| 100 | return true; |
| 101 | }, |
| 102 | ); |
| 103 | }); |
| 104 | }); |
| 105 | |
| 106 | test("release asset inventory includes binaries, archives, installer, and manifests", () => { |
| 107 | const { |
| 108 | allAssetNames, |
| 109 | allReleaseAssetNames, |
| 110 | BUNDLE_ASSET_NAMES, |
| 111 | BUNDLE_CHECKSUM_MANIFEST, |
| 112 | CHECKSUM_MANIFEST, |
| 113 | checksummedReleaseAssetNames, |
| 114 | LEGACY_TUI_BRIDGE_ASSET_NAMES, |
| 115 | WINDOWS_INSTALLER_ASSET, |
| 116 | } = require(ARTIFACTS_PATH); |
| 117 | const assetNames = allAssetNames(); |
| 118 | const releaseAssetNames = allReleaseAssetNames(); |
| 119 | assert.ok(assetNames.includes("codewhale-windows-x64.exe")); |
| 120 | assert.ok(assetNames.includes("codew-windows-x64.exe")); |
| 121 | assert.ok(assetNames.includes("codewhale.bat")); |
| 122 | assert.ok(assetNames.includes("codewhale-windows-arm64.exe")); |
| 123 | assert.ok(assetNames.includes("codew-windows-arm64.exe")); |
| 124 | assert.ok(assetNames.includes("codewhale-android-arm64")); |
| 125 | assert.ok(assetNames.includes("codew-android-arm64")); |
| 126 | assert.ok(!assetNames.includes("codewhale-tui-windows-x64.exe")); |
| 127 | assert.ok(!assetNames.includes("codewhale-tui-windows-arm64.exe")); |
| 128 | assert.ok(!assetNames.includes("codewhale-tui-android-arm64")); |
| 129 | assert.ok(!assetNames.includes("codewhale-linux-riscv64")); |
| 130 | assert.ok(releaseAssetNames.includes("codew-windows-x64.exe")); |
| 131 | assert.ok(releaseAssetNames.includes("codewhale.bat")); |
| 132 | assert.ok(releaseAssetNames.includes("codew-windows-arm64.exe")); |
| 133 | assert.ok(releaseAssetNames.includes("codew-android-arm64")); |
| 134 | for (const bridgeAsset of LEGACY_TUI_BRIDGE_ASSET_NAMES) { |
| 135 | assert.ok(releaseAssetNames.includes(bridgeAsset)); |
| 136 | assert.ok(!assetNames.includes(bridgeAsset)); |
| 137 | } |
| 138 | for (const bundle of BUNDLE_ASSET_NAMES) { |
| 139 | assert.ok(releaseAssetNames.includes(bundle)); |
| 140 | } |
| 141 | assert.ok(releaseAssetNames.includes(WINDOWS_INSTALLER_ASSET)); |
| 142 | assert.ok(releaseAssetNames.includes(BUNDLE_CHECKSUM_MANIFEST)); |
| 143 | assert.ok(releaseAssetNames.includes(CHECKSUM_MANIFEST)); |
| 144 | assert.ok(checksummedReleaseAssetNames().includes(BUNDLE_CHECKSUM_MANIFEST)); |
| 145 | assert.ok(!checksummedReleaseAssetNames().includes(CHECKSUM_MANIFEST)); |
| 146 | }); |
| 147 | |
| 148 | test("CNB mirror URLs use the repository that publishes release assets", () => { |
| 149 | withMockedOs("linux", "x64", () => { |
| 150 | const keys = [ |
| 151 | "CODEWHALE_RELEASE_BASE_URL", |
| 152 | "DEEPSEEK_TUI_RELEASE_BASE_URL", |
| 153 | "DEEPSEEK_RELEASE_BASE_URL", |
| 154 | "CODEWHALE_USE_CNB_MIRROR", |
| 155 | ]; |
| 156 | const previous = Object.fromEntries(keys.map((key) => [key, process.env[key]])); |
| 157 | try { |
| 158 | for (const key of keys) delete process.env[key]; |
| 159 | process.env.CODEWHALE_USE_CNB_MIRROR = "1"; |
| 160 | const { |
| 161 | checksumManifestUrl, |
| 162 | CNB_RELEASE_ASSET_NAMES, |
| 163 | releaseAssetUrl, |
| 164 | releaseBaseUrl, |
| 165 | } = require(ARTIFACTS_PATH); |
| 166 | |
| 167 | assert.deepEqual(CNB_RELEASE_ASSET_NAMES, [ |
| 168 | "codewhale-linux-x64", |
| 169 | "codew-linux-x64", |
| 170 | "codewhale-tui-linux-x64", |
| 171 | "codewhale-artifacts-sha256.txt", |
| 172 | ]); |
| 173 | assert.equal( |
| 174 | releaseBaseUrl("0.8.68"), |
| 175 | "https://cnb.cool/codewhale.net/codewhale/-/releases/download/v0.8.68/", |
| 176 | ); |
| 177 | assert.equal( |
| 178 | releaseAssetUrl("codewhale-linux-x64", "0.8.68"), |
| 179 | "https://cnb.cool/codewhale.net/codewhale/-/releases/download/v0.8.68/codewhale-linux-x64", |
| 180 | ); |
| 181 | assert.equal( |
| 182 | checksumManifestUrl("0.8.68"), |
| 183 | "https://cnb.cool/codewhale.net/codewhale/-/releases/download/v0.8.68/codewhale-artifacts-sha256.txt", |
| 184 | ); |
| 185 | } finally { |
| 186 | for (const key of keys) { |
| 187 | if (previous[key] === undefined) delete process.env[key]; |
| 188 | else process.env[key] = previous[key]; |
| 189 | } |
| 190 | } |
| 191 | }); |
| 192 | }); |
| 193 | |
| 194 | test("CNB mirror fails clearly outside its Linux x64 build matrix", () => { |
| 195 | withMockedOs("darwin", "arm64", () => { |
| 196 | const previous = process.env.CODEWHALE_USE_CNB_MIRROR; |
| 197 | process.env.CODEWHALE_USE_CNB_MIRROR = "1"; |
| 198 | try { |
| 199 | const { releaseBaseUrl } = require(ARTIFACTS_PATH); |
| 200 | assert.throws( |
| 201 | () => releaseBaseUrl("0.8.68"), |
| 202 | /currently supports only Linux x64.*detected darwin arm64/, |
| 203 | ); |
| 204 | } finally { |
| 205 | if (previous === undefined) delete process.env.CODEWHALE_USE_CNB_MIRROR; |
| 206 | else process.env.CODEWHALE_USE_CNB_MIRROR = previous; |
| 207 | } |
| 208 | }); |
| 209 | }); |
| 210 | |
| 211 | test("an explicit release base takes precedence over the CNB shortcut", () => { |
| 212 | withMockedOs("darwin", "arm64", () => { |
| 213 | const previousBase = process.env.CODEWHALE_RELEASE_BASE_URL; |
| 214 | const previousCnb = process.env.CODEWHALE_USE_CNB_MIRROR; |
| 215 | process.env.CODEWHALE_RELEASE_BASE_URL = "https://mirror.example/v0.8.68"; |
| 216 | process.env.CODEWHALE_USE_CNB_MIRROR = "1"; |
| 217 | try { |
| 218 | const { releaseBaseUrl, usesCnbMirror } = require(ARTIFACTS_PATH); |
| 219 | assert.equal(usesCnbMirror(), false); |
| 220 | assert.equal(releaseBaseUrl("0.8.68"), "https://mirror.example/v0.8.68/"); |
| 221 | } finally { |
| 222 | if (previousBase === undefined) delete process.env.CODEWHALE_RELEASE_BASE_URL; |
| 223 | else process.env.CODEWHALE_RELEASE_BASE_URL = previousBase; |
| 224 | if (previousCnb === undefined) delete process.env.CODEWHALE_USE_CNB_MIRROR; |
| 225 | else process.env.CODEWHALE_USE_CNB_MIRROR = previousCnb; |
| 226 | } |
| 227 | }); |
| 228 | }); |
| 229 |