tbeseda.com
this repo has no description
1import assert from 'node:assert/strict'
2import { mkdir, rm, writeFile } from 'node:fs/promises'
3import { join } from 'node:path'
4import { describe, test } from 'node:test'
5import { installRelease } from '../src/index.js'
6import { getPlatformInfo } from '../src/platform.js'
7
8describe('Binary Search Optimization', () => {
9 test('finds binary in root directory (fast path)', async (t) => {
10 // Mock a successful release and download
11 const mockReleaseData = {
12 tag_name: 'v1.0.0',
13 assets: [
14 {
15 name: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
16 browser_download_url: 'https://example.com/download',
17 size: 1024,
18 },
19 ],
20 }
21
22 t.mock.method(global, 'fetch', async (url: string) => {
23 if (url.includes('api.github.com')) {
24 return {
25 ok: true,
26 json: async () => mockReleaseData,
27 } as Response
28 }
29
30 // Mock download with minimal valid gzip content
31 return {
32 ok: true,
33 body: new ReadableStream({
34 start(controller) {
35 // Minimal valid gzip header + empty content + end markers
36 const gzipData = new Uint8Array([
37 0x1f,
38 0x8b,
39 0x08,
40 0x00,
41 0x00,
42 0x00,
43 0x00,
44 0x00,
45 0x00,
46 0xff, // gzip header
47 0x03,
48 0x00,
49 0x00,
50 0x00,
51 0x00,
52 0x00,
53 0x00,
54 0x00,
55 0x00,
56 0x00, // empty content + crc
57 ])
58 controller.enqueue(gzipData)
59 controller.close()
60 },
61 }),
62 } as Response
63 })
64
65 const currentPlatform = getPlatformInfo()
66 const testDir = './test-binary-root'
67
68 try {
69 // Pre-create the binary in root to test fast path
70 await mkdir(testDir, { recursive: true })
71 await writeFile(join(testDir, 'myapp'), 'fake binary content')
72
73 // This should use the fast path (direct lookup)
74 await installRelease('test/myapp', 'v1.0.0', {
75 outputDir: testDir,
76 platformMap: {
77 [currentPlatform.combined]: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
78 },
79 force: true, // Allow overwriting existing binary
80 verbose: true,
81 })
82
83 // Test should complete without errors
84 assert.ok(true, 'Binary found via fast path')
85 } finally {
86 await rm(testDir, { recursive: true }).catch(() => {})
87 }
88 })
89
90 test('finds binary in subdirectory (recursive path)', async (t) => {
91 // Mock a successful release and download
92 const mockReleaseData = {
93 tag_name: 'v1.0.0',
94 assets: [
95 {
96 name: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
97 browser_download_url: 'https://example.com/download',
98 size: 1024,
99 },
100 ],
101 }
102
103 t.mock.method(global, 'fetch', async (url: string) => {
104 if (url.includes('api.github.com')) {
105 return {
106 ok: true,
107 json: async () => mockReleaseData,
108 } as Response
109 }
110
111 return {
112 ok: true,
113 body: new ReadableStream({
114 start(controller) {
115 // Minimal valid gzip header + empty content + end markers
116 const gzipData = new Uint8Array([
117 0x1f,
118 0x8b,
119 0x08,
120 0x00,
121 0x00,
122 0x00,
123 0x00,
124 0x00,
125 0x00,
126 0xff, // gzip header
127 0x03,
128 0x00,
129 0x00,
130 0x00,
131 0x00,
132 0x00,
133 0x00,
134 0x00,
135 0x00,
136 0x00, // empty content + crc
137 ])
138 controller.enqueue(gzipData)
139 controller.close()
140 },
141 }),
142 } as Response
143 })
144
145 const currentPlatform = getPlatformInfo()
146 const testDir = './test-binary-subdir'
147
148 try {
149 // Pre-create binary in subdirectory to test recursive path
150 const subDir = join(testDir, 'bin')
151 await mkdir(subDir, { recursive: true })
152 await writeFile(join(subDir, 'myapp'), 'fake binary content')
153
154 // This should fall back to recursive search
155 await installRelease('test/myapp', 'v1.0.0', {
156 outputDir: testDir,
157 platformMap: {
158 [currentPlatform.combined]: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
159 },
160 force: true,
161 verbose: true,
162 })
163
164 assert.ok(true, 'Binary found via recursive search')
165 } finally {
166 await rm(testDir, { recursive: true }).catch(() => {})
167 }
168 })
169
170 test('handles binary not found scenario', async (t) => {
171 // Mock a successful release and download
172 const mockReleaseData = {
173 tag_name: 'v1.0.0',
174 assets: [
175 {
176 name: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
177 browser_download_url: 'https://example.com/download',
178 size: 1024,
179 },
180 ],
181 }
182
183 const consoleMessages: string[] = []
184 const originalConsoleLog = console.log
185 console.log = (message: string) => {
186 consoleMessages.push(message)
187 originalConsoleLog(message)
188 }
189
190 t.mock.method(global, 'fetch', async (url: string) => {
191 if (url.includes('api.github.com')) {
192 return {
193 ok: true,
194 json: async () => mockReleaseData,
195 } as Response
196 }
197
198 return {
199 ok: true,
200 body: new ReadableStream({
201 start(controller) {
202 // Minimal valid gzip header + empty content + end markers
203 const gzipData = new Uint8Array([
204 0x1f,
205 0x8b,
206 0x08,
207 0x00,
208 0x00,
209 0x00,
210 0x00,
211 0x00,
212 0x00,
213 0xff, // gzip header
214 0x03,
215 0x00,
216 0x00,
217 0x00,
218 0x00,
219 0x00,
220 0x00,
221 0x00,
222 0x00,
223 0x00, // empty content + crc
224 ])
225 controller.enqueue(gzipData)
226 controller.close()
227 },
228 }),
229 } as Response
230 })
231
232 const currentPlatform = getPlatformInfo()
233 const testDir = './test-binary-not-found'
234
235 try {
236 // Create empty directory - no binary to find
237 await mkdir(testDir, { recursive: true })
238
239 await installRelease('test/myapp', 'v1.0.0', {
240 outputDir: testDir,
241 platformMap: {
242 [currentPlatform.combined]: 'myapp-v1.0.0-x86_64-apple-darwin.tar.gz',
243 },
244 force: true,
245 verbose: true,
246 })
247
248 // Should have logged a warning about binary not found
249 const warningMessages = consoleMessages.filter(
250 (msg) => msg.includes('Warning: Binary') && msg.includes('not found'),
251 )
252 assert.equal(warningMessages.length, 1, 'Should log warning when binary not found')
253 } finally {
254 console.log = originalConsoleLog
255 await rm(testDir, { recursive: true }).catch(() => {})
256 }
257 })
258
259 test('finds .exe binary on Windows-style naming', async (t) => {
260 // Mock a successful release and download
261 const mockReleaseData = {
262 tag_name: 'v1.0.0',
263 assets: [
264 {
265 name: 'myapp-v1.0.0-x86_64-pc-windows.zip',
266 browser_download_url: 'https://example.com/download',
267 size: 1024,
268 },
269 ],
270 }
271
272 t.mock.method(global, 'fetch', async (url: string) => {
273 if (url.includes('api.github.com')) {
274 return {
275 ok: true,
276 json: async () => mockReleaseData,
277 } as Response
278 }
279
280 return {
281 ok: true,
282 body: new ReadableStream({
283 start(controller) {
284 // Create fake zip content for Windows test
285 controller.enqueue(new Uint8Array([0x50, 0x4b, 0x03, 0x04])) // ZIP header
286 controller.close()
287 },
288 }),
289 } as Response
290 })
291
292 const currentPlatform = getPlatformInfo()
293 const testDir = './test-binary-exe'
294
295 try {
296 // Pre-create .exe binary to test Windows naming
297 await mkdir(testDir, { recursive: true })
298 await writeFile(join(testDir, 'myapp.exe'), 'fake exe content')
299
300 // This test may fail on non-Windows systems due to missing zip tools
301 // but that's expected behavior - we're testing the binary naming logic
302 try {
303 await installRelease('test/myapp', 'v1.0.0', {
304 outputDir: testDir,
305 platformMap: {
306 [currentPlatform.combined]: 'myapp-v1.0.0-x86_64-pc-windows.zip',
307 },
308 force: true,
309 verbose: true,
310 })
311 assert.ok(true, 'Binary with .exe extension found')
312 } catch (error) {
313 // If zip extraction fails (expected on non-Windows), that's still a valid test
314 // since we're mainly testing the asset download and binary naming logic
315 if (error.message.includes('Failed to extract zip file')) {
316 assert.ok(true, 'Test completed - zip extraction not available on this platform')
317 } else {
318 throw error // Re-throw unexpected errors
319 }
320 }
321 } finally {
322 await rm(testDir, { recursive: true }).catch(() => {})
323 }
324 })
325})