@goliapkg/sentori-cli 0.5.3 → 0.6.0

package/src/__tests__/source-bundle.test.ts

@@ -0,0 +1,105 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { uploadSourceBundle } from '../source-bundle.js'
+
+const ADMIN = {
+  apiUrl: 'https://api.example.com/',
+  projectId: 'proj-1',
+  release: 'myapp@1.0.0',
+  token: 'sk_test',
+}
+
+let dir = ''
+const origFetch = globalThis.fetch
+let calls: { body: Buffer | null; headers: Headers; url: string }[]
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'sentori-cli-srcbun-'))
+  calls = []
+})
+afterEach(async () => {
+  globalThis.fetch = origFetch
+  await rm(dir, { force: true, recursive: true })
+})
+
+function mockFetch(status = 201, body: object = { contentHash: 'h', kind: 'source_bundle_ios', sizeBytes: 12 }): void {
+  globalThis.fetch = (async (url: Request | string | URL, init?: RequestInit) => {
+    const b = init?.body
+    calls.push({
+      body: b instanceof Uint8Array ? Buffer.from(b) : null,
+      headers: new Headers(init?.headers),
+      url: String(url),
+    })
+    return new Response(JSON.stringify(body), { status })
+  }) as typeof fetch
+}
+
+describe('uploadSourceBundle', () => {
+  test('rejects unknown platform', async () => {
+    const path = join(dir, 'a.tar.gz')
+    await writeFile(path, Buffer.from([0x1f, 0x8b, 0x08, 0x00]))
+    mockFetch()
+    await expect(
+      uploadSourceBundle({ ...ADMIN, path, platform: 'windows' as unknown as 'ios' }),
+    ).rejects.toThrow(/platform/)
+  })
+
+  test('rejects non-gzip body before hitting network', async () => {
+    const path = join(dir, 'not-gzip.tar.gz')
+    await writeFile(path, Buffer.from('plain text not a gzip stream'))
+    mockFetch()
+    await expect(
+      uploadSourceBundle({ ...ADMIN, path, platform: 'ios' }),
+    ).rejects.toThrow(/gzip|1f 8b/i)
+    expect(calls.length).toBe(0)
+  })
+
+  test('rejects empty body', async () => {
+    const path = join(dir, 'empty.tar.gz')
+    await writeFile(path, Buffer.alloc(0))
+    mockFetch()
+    await expect(uploadSourceBundle({ ...ADMIN, path, platform: 'ios' })).rejects.toThrow(
+      /empty/,
+    )
+  })
+
+  test('posts to /admin/api/projects/<id>/source-bundles with platform + release query', async () => {
+    const path = join(dir, 'src.tar.gz')
+    // gzip magic + minimal payload — server-side validation passes.
+    await writeFile(path, Buffer.from([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00]))
+    mockFetch(201, { contentHash: 'abc123', kind: 'source_bundle_ios', sizeBytes: 6 })
+
+    const r = await uploadSourceBundle({ ...ADMIN, path, platform: 'ios' })
+
+    expect(calls.length).toBe(1)
+    expect(calls[0]!.url).toContain('/admin/api/projects/proj-1/source-bundles?')
+    expect(calls[0]!.url).toContain('platform=ios')
+    expect(calls[0]!.url).toContain('release=myapp%401.0.0')
+    expect(calls[0]!.headers.get('authorization')).toBe('Bearer sk_test')
+    expect(calls[0]!.headers.get('content-type')).toBe('application/gzip')
+    expect(r.kind).toBe('source_bundle_ios')
+    expect(r.contentHash).toBe('abc123')
+  })
+
+  test('android platform routes the same shape', async () => {
+    const path = join(dir, 'src.tar.gz')
+    await writeFile(path, Buffer.from([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00]))
+    mockFetch(201, { contentHash: 'def', kind: 'source_bundle_android', sizeBytes: 6 })
+    const r = await uploadSourceBundle({ ...ADMIN, path, platform: 'android' })
+    expect(calls[0]!.url).toContain('platform=android')
+    expect(r.kind).toBe('source_bundle_android')
+  })
+
+  test('surfaces server 4xx/5xx as Error with snippet', async () => {
+    const path = join(dir, 'src.tar.gz')
+    await writeFile(path, Buffer.from([0x1f, 0x8b]))
+    mockFetch(500, { error: { code: 'bad', message: 'boom on server' } })
+    await expect(uploadSourceBundle({ ...ADMIN, path, platform: 'ios' })).rejects.toThrow(
+      /500/,
+    )
+  })
+})

package/src/__tests__/upload.test.ts

@@ -0,0 +1,121 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { collectFiles, uploadSourcemaps } from '../upload.js'
+
+let dir = ''
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'sentori-cli-test-'))
+  await writeFile(join(dir, 'main.jsbundle'), '/*bundle*/')
+  await writeFile(join(dir, 'main.jsbundle.map'), '{"version":3}')
+  await writeFile(join(dir, 'app.js'), 'console.log(1)')
+  await writeFile(join(dir, 'app.js.map'), '{"version":3}')
+  await writeFile(join(dir, 'README.txt'), 'not a build artifact')
+})
+afterEach(async () => {
+  await rm(dir, { force: true, recursive: true })
+})
+
+describe('collectFiles', () => {
+  test('a directory yields its .map / .js / .bundle files, not others', async () => {
+    const files = await collectFiles([dir])
+    const names = files.map((f) => f.replace(`${dir}/`, '')).sort()
+    expect(names).toEqual(['app.js', 'app.js.map', 'main.jsbundle', 'main.jsbundle.map'])
+  })
+
+  test('an explicit file is taken as-is regardless of extension', async () => {
+    const files = await collectFiles([join(dir, 'README.txt')])
+    expect(files).toEqual([join(dir, 'README.txt')])
+  })
+
+  test('dedupes when a file is named both directly and via its dir', async () => {
+    const files = await collectFiles([dir, join(dir, 'app.js.map')])
+    expect(files.filter((f) => f.endsWith('app.js.map'))).toHaveLength(1)
+  })
+
+  test('throws on a nonexistent path', async () => {
+    await expect(collectFiles([join(dir, 'nope')])).rejects.toThrow('no such file or directory')
+  })
+
+  test('throws when a directory has no uploadable files', async () => {
+    const empty = await mkdtemp(join(tmpdir(), 'sentori-cli-empty-'))
+    try {
+      await expect(collectFiles([empty])).rejects.toThrow('no .map')
+    } finally {
+      await rm(empty, { force: true, recursive: true })
+    }
+  })
+})
+
+describe('uploadSourcemaps', () => {
+  test('dryRun returns the file list, makes no request', async () => {
+    let called = false
+    const orig = globalThis.fetch
+    globalThis.fetch = (async () => {
+      called = true
+      return new Response()
+    }) as typeof fetch
+    try {
+      const r = await uploadSourcemaps({
+        apiUrl: 'https://api.example.com',
+        dryRun: true,
+        paths: [dir],
+        release: 'app@1.0.0+1',
+        token: 'st_pk_x',
+      })
+      expect(r.files).toHaveLength(4)
+      expect(called).toBe(false)
+    } finally {
+      globalThis.fetch = orig
+    }
+  })
+
+  test('POSTs multipart to /admin/api/releases/<release>/sourcemaps with the token', async () => {
+    const calls: { headers: Headers; url: string }[] = []
+    const orig = globalThis.fetch
+    globalThis.fetch = (async (url: Request | string | URL, init?: RequestInit) => {
+      calls.push({ headers: new Headers(init?.headers), url: String(url) })
+      return new Response(JSON.stringify({ artifacts: [], uploaded: 4 }), {
+        headers: { 'content-type': 'application/json' },
+        status: 200,
+      })
+    }) as typeof fetch
+    try {
+      const r = await uploadSourcemaps({
+        apiUrl: 'https://api.example.com/',
+        paths: [dir],
+        release: 'my app@1.0.0+1',
+        token: 'st_pk_secret',
+      })
+      expect(calls).toHaveLength(1)
+      expect(calls[0]?.url).toBe(
+        'https://api.example.com/admin/api/releases/my%20app%401.0.0%2B1/sourcemaps',
+      )
+      expect(calls[0]?.headers.get('authorization')).toBe('Bearer st_pk_secret')
+      expect(r.uploaded).toBe(4)
+    } finally {
+      globalThis.fetch = orig
+    }
+  })
+
+  test('throws with the server detail on a non-2xx response', async () => {
+    const orig = globalThis.fetch
+    globalThis.fetch = (async () =>
+      new Response('release frozen', { status: 403, statusText: 'Forbidden' })) as typeof fetch
+    try {
+      await expect(
+        uploadSourcemaps({
+          apiUrl: 'https://api.example.com',
+          paths: [dir],
+          release: 'app@1.0.0+1',
+          token: 'st_pk_x',
+        }),
+      ).rejects.toThrow('403 Forbidden — release frozen')
+    } finally {
+      globalThis.fetch = orig
+    }
+  })
+})