@atproto/bsky 0.0.103 → 0.0.104

package/tests/_util.ts

@@ -1,14 +1,18 @@
-import { AtUri } from '@atproto/syntax'
+import { AppBskyFeedGetPostThread } from '@atproto/api'
 import { lexToJson } from '@atproto/lexicon'
+import { AtUri } from '@atproto/syntax'
+import { type Express } from 'express'
 import { CID } from 'multiformats/cid'
+import { Server } from 'node:http'
+
+import { AddressInfo } from 'node:net'
+import { isViewRecord } from '../src/lexicon/types/app/bsky/embed/record'
 import {
   FeedViewPost,
   PostView,
   isPostView,
   isThreadViewPost,
 } from '../src/lexicon/types/app/bsky/feed/defs'
-import { isViewRecord } from '../src/lexicon/types/app/bsky/embed/record'
-import { AppBskyFeedGetPostThread } from '@atproto/api'
 import {
   LabelerView,
   isLabelerView,
@@ -234,3 +238,46 @@ export const stripViewerFromLabeler = (
   labeler.creator = stripViewer(labeler.creator)
   return stripViewer(labeler)
 }
+
+export async function startServer(app: Express) {
+  return new Promise<{
+    origin: string
+    server: Server
+    stop: () => Promise<void>
+  }>((resolve, reject) => {
+    const onListen = () => {
+      const port = (server.address() as AddressInfo).port
+      resolve({
+        server,
+        origin: `http://localhost:${port}`,
+        stop: () => stopServer(server),
+      })
+      cleanup()
+    }
+    const onError = (err: Error) => {
+      reject(err)
+      cleanup()
+    }
+    const cleanup = () => {
+      server.removeListener('listening', onListen)
+      server.removeListener('error', onError)
+    }
+
+    const server = app
+      .listen(0)
+      .once('listening', onListen)
+      .once('error', onError)
+  })
+}
+
+export async function stopServer(server: Server) {
+  return new Promise<void>((resolve, reject) => {
+    server.close((err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+  })
+}

package/tests/blob-resolver.test.ts

@@ -1,14 +1,14 @@
-import axios, { AxiosInstance } from 'axios'
-import { CID } from 'multiformats/cid'
 import { cidForCbor, verifyCidForBytes } from '@atproto/common'
-import { TestNetwork, basicSeed } from '@atproto/dev-env'
 import { randomBytes } from '@atproto/crypto'
+import { TestNetwork, basicSeed } from '@atproto/dev-env'
+import { CID } from 'multiformats/cid'
+import { request } from 'undici'
 
 describe('blob resolver', () => {
   let network: TestNetwork
-  let client: AxiosInstance
   let fileDid: string
   let fileCid: CID
+  let fileSize: number
 
   beforeAll(async () => {
     network = await TestNetwork.create({
@@ -19,10 +19,7 @@ describe('blob resolver', () => {
     await network.processAll()
     fileDid = sc.dids.carol
     fileCid = sc.posts[fileDid][0].images[0].image.ref
-    client = axios.create({
-      baseURL: network.bsky.url,
-      validateStatus: () => true,
-    })
+    fileSize = sc.posts[fileDid][0].images[0].image.size
   })
 
   afterAll(async () => {
@@ -30,70 +27,99 @@ describe('blob resolver', () => {
   })
 
   it('resolves blob with good signature check.', async () => {
-    const { data, status, headers } = await client.get(
-      `/blob/${fileDid}/${fileCid.toString()}`,
-      { responseType: 'arraybuffer' },
+    const response = await request(
+      new URL(`/blob/${fileDid}/${fileCid.toString()}`, network.bsky.url),
     )
-    expect(status).toEqual(200)
-    expect(headers['content-type']).toEqual('image/jpeg')
-    expect(headers['content-security-policy']).toEqual(
+    expect(response.statusCode).toEqual(200)
+    expect(response.headers['content-type']).toEqual('image/jpeg')
+    expect(response.headers['content-security-policy']).toEqual(
       `default-src 'none'; sandbox`,
     )
-    expect(headers['x-content-type-options']).toEqual('nosniff')
-    await expect(verifyCidForBytes(fileCid, data)).resolves.toBeUndefined()
+    expect(response.headers['x-content-type-options']).toEqual('nosniff')
+
+    const bytes = new Uint8Array(await response.body.arrayBuffer())
+    await expect(verifyCidForBytes(fileCid, bytes)).resolves.toBeUndefined()
   })
 
   it('404s on missing blob.', async () => {
     const badCid = await cidForCbor({ unknown: true })
-    const { data, status } = await client.get(
-      `/blob/${fileDid}/${badCid.toString()}`,
+    const response = await request(
+      new URL(`/blob/${fileDid}/${badCid.toString()}`, network.bsky.url),
     )
-    expect(status).toEqual(404)
-    expect(data).toEqual({
+    expect(response.statusCode).toEqual(404)
+    await expect(response.body.json()).resolves.toEqual({
       error: 'NotFoundError',
       message: 'Blob not found',
     })
   })
 
   it('404s on missing identity.', async () => {
-    const { data, status } = await client.get(
-      `/blob/did:plc:unknown/${fileCid.toString()}`,
+    const nonExistingDid = `did:plc:${'a'.repeat(24)}`
+
+    const response = await request(
+      new URL(
+        `/blob/${nonExistingDid}/${fileCid.toString()}`,
+        network.bsky.url,
+      ),
     )
-    expect(status).toEqual(404)
-    expect(data).toEqual({
+    expect(response.statusCode).toEqual(404)
+    await expect(response.body.json()).resolves.toEqual({
       error: 'NotFoundError',
       message: 'Origin not found',
     })
   })
 
   it('400s on invalid did.', async () => {
-    const { data, status } = await client.get(
-      `/blob/did::/${fileCid.toString()}`,
+    const response = await request(
+      new URL(`/blob/did::/${fileCid.toString()}`, network.bsky.url),
     )
-    expect(status).toEqual(400)
-    expect(data).toEqual({
+    expect(response.statusCode).toEqual(400)
+    await expect(response.body.json()).resolves.toEqual({
       error: 'BadRequestError',
       message: 'Invalid did',
     })
   })
 
   it('400s on invalid cid.', async () => {
-    const { data, status } = await client.get(`/blob/${fileDid}/barfy`)
-    expect(status).toEqual(400)
-    expect(data).toEqual({
+    const response = await request(
+      new URL(`/blob/${fileDid}/barfy`, network.bsky.url),
+    )
+    expect(response.statusCode).toEqual(400)
+    await expect(response.body.json()).resolves.toEqual({
       error: 'BadRequestError',
       message: 'Invalid cid',
     })
   })
 
-  it('fails on blob with bad signature check.', async () => {
+  it('400s on missing file.', async () => {
+    const missingCid = await cidForCbor('missing-file')
+
+    const response = await request(
+      new URL(`/blob/${fileDid}/${missingCid}`, network.bsky.url),
+    )
+    expect(response.statusCode).toEqual(404)
+    await expect(response.body.json()).resolves.toEqual({
+      error: 'NotFoundError',
+      message: 'Blob not found',
+    })
+  })
+
+  it('replaces the file with invalid bytes.', async () => {
     await network.pds.ctx.blobstore(fileDid).delete(fileCid)
     await network.pds.ctx
       .blobstore(fileDid)
-      .putPermanent(fileCid, randomBytes(100))
-    const tryGetBlob = client.get(`/blob/${fileDid}/${fileCid.toString()}`)
-    await expect(tryGetBlob).rejects.toThrow(
-      'maxContentLength size of -1 exceeded',
+      .putPermanent(fileCid, randomBytes(fileSize))
+  })
+
+  it('fails to fetch bytes on blob with bad signature check.', async () => {
+    const response = await request(
+      new URL(`/blob/${fileDid}/${fileCid.toString()}`, network.bsky.url),
     )
+
+    expect(response.statusCode).toEqual(404)
+    await expect(response.body.json()).resolves.toEqual({
+      error: 'NotFoundError',
+      message: 'Bad cid check',
+    })
   })
 })

package/tests/image/server.test.ts

@@ -1,13 +1,12 @@
-import axios, { AxiosInstance } from 'axios'
-import { CID } from 'multiformats/cid'
 import { cidForCbor } from '@atproto/common'
 import { TestNetwork, basicSeed } from '@atproto/dev-env'
+import { CID } from 'multiformats/cid'
+import { Readable } from 'node:stream'
 import { getInfo } from '../../src/image/sharp'
 import { ImageUriBuilder } from '../../src/image/uri'
 
 describe('image processing server', () => {
   let network: TestNetwork
-  let client: AxiosInstance
   let fileDid: string
   let fileCid: CID
 
@@ -20,10 +19,6 @@ describe('image processing server', () => {
     await network.processAll()
     fileDid = sc.dids.carol
     fileCid = sc.posts[fileDid][0].images[0].image.ref
-    client = axios.create({
-      baseURL: `${network.bsky.url}/img`,
-      validateStatus: () => true,
-    })
   })
 
   afterAll(async () => {
@@ -31,16 +26,19 @@ describe('image processing server', () => {
   })
 
   it('processes image from blob resolver.', async () => {
-    const res = await client.get(
-      ImageUriBuilder.getPath({
-        preset: 'feed_fullsize',
-        did: fileDid,
-        cid: fileCid.toString(),
-      }),
-      { responseType: 'stream' },
+    const res = await fetch(
+      new URL(
+        `/img${ImageUriBuilder.getPath({
+          preset: 'feed_fullsize',
+          did: fileDid,
+          cid: fileCid.toString(),
+        })}`,
+        network.bsky.url,
+      ),
     )
 
-    const info = await getInfo(res.data)
+    const bytes = new Uint8Array(await res.arrayBuffer())
+    const info = await getInfo(Readable.from([bytes]))
 
     expect(info).toEqual({
       height: 580,
@@ -48,7 +46,7 @@ describe('image processing server', () => {
       size: 127578,
       mime: 'image/jpeg',
     })
-    expect(res.headers).toEqual(
+    expect(Object.fromEntries(res.headers)).toEqual(
       expect.objectContaining({
         'content-type': 'image/jpeg',
         'cache-control': 'public, max-age=31536000',
@@ -63,26 +61,36 @@ describe('image processing server', () => {
       did: fileDid,
       cid: fileCid.toString(),
     })
-    const res1 = await client.get(path, { responseType: 'arraybuffer' })
-    expect(res1.headers['x-cache']).toEqual('miss')
-    const res2 = await client.get(path, { responseType: 'arraybuffer' })
-    expect(res2.headers['x-cache']).toEqual('hit')
-    const res3 = await client.get(path, { responseType: 'arraybuffer' })
-    expect(res3.headers['x-cache']).toEqual('hit')
-    expect(Buffer.compare(res1.data, res2.data)).toEqual(0)
-    expect(Buffer.compare(res1.data, res3.data)).toEqual(0)
+    const url = new URL(`/img${path}`, network.bsky.url)
+
+    const res1 = await fetch(url)
+    expect(res1.headers.get('x-cache')).toEqual('miss')
+    const bytes1 = new Uint8Array(await res1.arrayBuffer())
+    const res2 = await fetch(url)
+    expect(res2.headers.get('x-cache')).toEqual('hit')
+    const bytes2 = new Uint8Array(await res2.arrayBuffer())
+    const res3 = await fetch(url)
+    expect(res3.headers.get('x-cache')).toEqual('hit')
+    const bytes3 = new Uint8Array(await res3.arrayBuffer())
+    expect(Buffer.compare(bytes1, bytes2)).toEqual(0)
+    expect(Buffer.compare(bytes1, bytes3)).toEqual(0)
   })
 
   it('errors on missing file.', async () => {
     const missingCid = await cidForCbor('missing-file')
-    const res = await client.get(
-      ImageUriBuilder.getPath({
-        preset: 'feed_fullsize',
-        did: fileDid,
-        cid: missingCid.toString(),
-      }),
-    )
+
+    const path = ImageUriBuilder.getPath({
+      preset: 'feed_fullsize',
+      did: fileDid,
+      cid: missingCid.toString(),
+    })
+
+    const url = new URL(`/img${path}`, network.bsky.url)
+
+    const res = await fetch(url)
     expect(res.status).toEqual(404)
-    expect(res.data).toEqual({ message: 'Image not found' })
+    await expect(res.json()).resolves.toMatchObject({
+      message: 'Blob not found',
+    })
   })
 })

package/tests/image/sharp.test.ts

@@ -1,5 +1,11 @@
-import { createReadStream } from 'fs'
-import { Options, getInfo, resize } from '../../src/image/sharp'
+import { createReadStream } from 'node:fs'
+import { pipeline } from 'node:stream/promises'
+import {
+  Options,
+  createImageProcessor,
+  createImageUpscaler,
+  getInfo,
+} from '../../src/image/sharp'
 
 describe('sharp image processor', () => {
   it('scales up to cover.', async () => {
@@ -179,7 +185,14 @@ describe('sharp image processor', () => {
 
   async function processFixture(fixture: string, options: Options) {
     const image = createReadStream(`../dev-env/assets/${fixture}`)
-    const resized = await resize(image, options)
-    return await getInfo(resized)
+    const upscaler = createImageUpscaler(options)
+    const processor = createImageProcessor(options)
+
+    const [info] = await Promise.all([
+      getInfo(processor),
+      pipeline([image, upscaler, processor]),
+    ])
+
+    return info
   }
 })

package/tests/label-hydration.test.ts

@@ -1,6 +1,5 @@
 import { AtpAgent } from '@atproto/api'
 import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import axios from 'axios'
 
 describe('label hydration', () => {
   let network: TestNetwork
@@ -81,15 +80,16 @@ describe('label hydration', () => {
   })
 
   it('defaults to service labels when no labeler header is provided', async () => {
-    const res = await axios.get(
+    const res = await fetch(
       `${network.pds.url}/xrpc/app.bsky.actor.getProfile?actor=${carol}`,
       { headers: sc.getHeaders(bob) },
     )
-    expect(res.data.labels?.length).toBe(1)
-    expect(res.data.labels?.[0].src).toBe(labelerDid)
-    expect(res.data.labels?.[0].val).toBe('misleading')
+    const data = await res.json()
+    expect(data.labels?.length).toBe(1)
+    expect(data.labels?.[0].src).toBe(labelerDid)
+    expect(data.labels?.[0].val).toBe('misleading')
 
-    expect(res.headers['atproto-content-labelers']).toEqual(
+    expect(res.headers.get('atproto-content-labelers')).toEqual(
       network.bsky.ctx.cfg.labelsFromIssuerDids
         .map((did) => `${did};redact`)
         .join(','),

package/tests/server.test.ts

@@ -1,9 +1,11 @@
-import { AddressInfo } from 'net'
-import express from 'express'
-import axios, { AxiosError } from 'axios'
 import { TestNetwork, basicSeed } from '@atproto/dev-env'
+import express from 'express'
+import { once } from 'node:events'
+import { AddressInfo } from 'node:net'
+import { finished } from 'node:stream/promises'
+import { request } from 'undici'
 import { handler as errorHandler } from '../src/error'
-import { once } from 'events'
+import { startServer } from './_util'
 
 describe('server', () => {
   let network: TestNetwork
@@ -24,8 +26,8 @@ describe('server', () => {
   })
 
   it('preserves 404s.', async () => {
-    const promise = axios.get(`${network.bsky.url}/unknown`)
-    await expect(promise).rejects.toThrow('failed with status code 404')
+    const response = await fetch(`${network.bsky.url}/unknown`)
+    expect(response.status).toEqual(404)
   })
 
   it('error handler turns unknown errors into 500s.', async () => {
@@ -34,99 +36,82 @@ describe('server', () => {
       throw new Error('Oops!')
     })
     app.use(errorHandler)
-    const srv = app.listen()
-    const port = (srv.address() as AddressInfo).port
-    const promise = axios.get(`http://localhost:${port}/oops`)
-    await expect(promise).rejects.toThrow('failed with status code 500')
-    srv.close()
+    const { origin, stop } = await startServer(app)
     try {
-      await promise
-    } catch (err: unknown) {
-      const axiosError = err as AxiosError
-      expect(axiosError.response?.status).toEqual(500)
-      expect(axiosError.response?.data).toEqual({
+      const response = await fetch(new URL(`/oops`, origin))
+      expect(response.status).toEqual(500)
+      await expect(response.json()).resolves.toEqual({
         error: 'InternalServerError',
         message: 'Internal Server Error',
       })
+    } finally {
+      await stop()
     }
   })
 
   it('healthcheck succeeds when database is available.', async () => {
-    const { data, status } = await axios.get(`${network.bsky.url}/xrpc/_health`)
-    expect(status).toEqual(200)
-    expect(data).toEqual({ version: 'unknown' })
+    const response = await fetch(`${network.bsky.url}/xrpc/_health`)
+    expect(response.status).toEqual(200)
+    await expect(response.json()).resolves.toEqual({ version: 'unknown' })
   })
 
   // TODO(bsky) check on a different endpoint that accepts json, currently none.
   it.skip('limits size of json input.', async () => {
-    let error: AxiosError
-    try {
-      await axios.post(
-        `${network.bsky.url}/xrpc/com.atproto.repo.createRecord`,
-        {
-          data: 'x'.repeat(100 * 1024), // 100kb
-        },
-        // { headers: sc.getHeaders(alice) },
-      )
-      throw new Error('Request should have failed')
-    } catch (err) {
-      if (axios.isAxiosError(err)) {
-        error = err
-      } else {
-        throw err
-      }
-    }
-    expect(error.response?.status).toEqual(413)
-    expect(error.response?.data).toEqual({
+    const response = await fetch(
+      `${network.bsky.url}/xrpc/com.atproto.repo.createRecord`,
+      {
+        body: 'x'.repeat(100 * 1024), // 100kb
+      },
+    )
+
+    expect(response.status).toEqual(413)
+    await expect(response.json()).resolves.toEqual({
       error: 'PayloadTooLargeError',
       message: 'request entity too large',
     })
   })
 
   it('compresses large json responses', async () => {
-    const res = await axios.get(
+    const res = await request(
       `${network.bsky.url}/xrpc/app.bsky.feed.getTimeline`,
       {
-        decompress: false,
         headers: {
           ...(await network.serviceHeaders(alice, 'app.bsky.feed.getTimeline')),
           'accept-encoding': 'gzip',
         },
       },
     )
+
+    await finished(res.body.resume())
+
     expect(res.headers['content-encoding']).toEqual('gzip')
   })
 
   it('does not compress small payloads', async () => {
-    const res = await axios.get(`${network.bsky.url}/xrpc/_health`, {
-      decompress: false,
+    const res = await request(`${network.bsky.url}/xrpc/_health`, {
       headers: { 'accept-encoding': 'gzip' },
     })
+
+    await finished(res.body.resume())
+
     expect(res.headers['content-encoding']).toBeUndefined()
   })
 
   it('healthcheck fails when dataplane is unavailable.', async () => {
     const { port } = network.bsky.dataplane.server.address() as AddressInfo
     await network.bsky.dataplane.destroy()
-    let error: AxiosError
+
     try {
-      await axios.get(`${network.bsky.url}/xrpc/_health`)
-      throw new Error('Healthcheck should have failed')
-    } catch (err) {
-      if (axios.isAxiosError(err)) {
-        error = err
-      } else {
-        throw err
-      }
+      const response = await fetch(`${network.bsky.url}/xrpc/_health`)
+      expect(response.status).toEqual(503)
+      await expect(response.json()).resolves.toEqual({
+        version: 'unknown',
+        error: 'Service Unavailable',
+      })
     } finally {
       // restart dataplane server to allow test suite to cleanup
       network.bsky.dataplane.server.listen(port)
       await once(network.bsky.dataplane.server, 'listening')
     }
-    expect(error.response?.status).toEqual(503)
-    expect(error.response?.data).toEqual({
-      version: 'unknown',
-      error: 'Service Unavailable',
-    })
   })
 })