@atproto/xrpc-server 0.10.14 → 0.10.16

package/tests/procedures.test.ts

@@ -5,9 +5,14 @@ import { Readable } from 'node:stream'
 import { LexiconDoc } from '@atproto/lexicon'
 import { XrpcClient } from '@atproto/xrpc'
 import * as xrpcServer from '../src'
-import { closeServer, createServer } from './_util'
+import {
+  buildAddLexicons,
+  buildMethodLexicons,
+  closeServer,
+  createServer,
+} from './_util'
 
-const LEXICONS: LexiconDoc[] = [
+const LEXICONS = [
   {
     lexicon: 1,
     id: 'io.example.pingOne',
@@ -81,18 +86,16 @@ const LEXICONS: LexiconDoc[] = [
       },
     },
   },
-]
+] as const satisfies LexiconDoc[]
 
-describe('Procedures', () => {
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS)
-  server.method('io.example.pingOne', (ctx) => {
+const handlers = {
+  'io.example.pingOne': (ctx: xrpcServer.HandlerContext) => {
     return { encoding: 'text/plain', body: ctx.params.message }
-  })
-  server.method('io.example.pingTwo', (ctx) => {
+  },
+  'io.example.pingTwo': (ctx: xrpcServer.HandlerContext) => {
     return { encoding: 'text/plain', body: ctx.input?.body }
-  })
-  server.method('io.example.pingThree', async (ctx) => {
+  },
+  'io.example.pingThree': async (ctx: xrpcServer.HandlerContext) => {
     assert(ctx.input?.body instanceof Readable, 'Input not readable')
     const buffers: Buffer[] = []
     for await (const data of ctx.input.body) {
@@ -102,56 +105,72 @@ describe('Procedures', () => {
       encoding: 'application/octet-stream',
       body: Buffer.concat(buffers),
     }
-  })
-  server.method('io.example.pingFour', (ctx) => {
+  },
+  'io.example.pingFour': (ctx: xrpcServer.HandlerContext) => {
     return {
       encoding: 'application/json',
       body: { message: ctx.input?.body?.['message'] },
     }
-  })
+  },
+}
 
-  let client: XrpcClient
-  beforeAll(async () => {
-    s = await createServer(server)
-    const { port } = s.address() as AddressInfo
-    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
-  })
-  afterAll(async () => {
-    await closeServer(s)
-  })
+for (const buildServer of [buildMethodLexicons, buildAddLexicons]) {
+  describe(buildServer, () => {
+    let s: http.Server
+    let client: XrpcClient
+    let url: string
+    beforeAll(async () => {
+      const server = await buildServer(LEXICONS, handlers)
+      s = await createServer(server)
+      const { port } = s.address() as AddressInfo
+      url = `http://localhost:${port}`
+      client = new XrpcClient(url, LEXICONS)
+    })
+    afterAll(async () => {
+      if (s) await closeServer(s)
+    })
 
-  it('serves requests', async () => {
-    const res1 = await client.call('io.example.pingOne', {
-      message: 'hello world',
+    test('io.example.pingOne', async () => {
+      const res = await client.call('io.example.pingOne', {
+        message: 'hello world',
+      })
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe('text/plain; charset=utf-8')
+      expect(res.data).toBe('hello world')
     })
-    expect(res1.success).toBeTruthy()
-    expect(res1.headers['content-type']).toBe('text/plain; charset=utf-8')
-    expect(res1.data).toBe('hello world')
 
-    const res2 = await client.call('io.example.pingTwo', {}, 'hello world', {
-      encoding: 'text/plain',
+    test('io.example.pingTwo', async () => {
+      const res = await client.call('io.example.pingTwo', {}, 'hello world', {
+        encoding: 'text/plain',
+      })
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe('text/plain; charset=utf-8')
+      expect(res.data).toBe('hello world')
     })
-    expect(res2.success).toBeTruthy()
-    expect(res2.headers['content-type']).toBe('text/plain; charset=utf-8')
-    expect(res2.data).toBe('hello world')
 
-    const res3 = await client.call(
-      'io.example.pingThree',
-      {},
-      new TextEncoder().encode('hello world'),
-      { encoding: 'application/octet-stream' },
-    )
-    expect(res3.success).toBeTruthy()
-    expect(res3.headers['content-type']).toBe('application/octet-stream')
-    expect(new TextDecoder().decode(res3.data)).toBe('hello world')
+    test('io.example.pingThree', async () => {
+      const res = await client.call(
+        'io.example.pingThree',
+        {},
+        new TextEncoder().encode('hello world'),
+        { encoding: 'application/octet-stream' },
+      )
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe('application/octet-stream')
+      expect(new TextDecoder().decode(res.data)).toBe('hello world')
+    })
 
-    const res4 = await client.call(
-      'io.example.pingFour',
-      {},
-      { message: 'hello world' },
-    )
-    expect(res4.success).toBeTruthy()
-    expect(res4.headers['content-type']).toBe('application/json; charset=utf-8')
-    expect(res4.data?.message).toBe('hello world')
+    test('io.example.pingFour', async () => {
+      const res = await client.call(
+        'io.example.pingFour',
+        {},
+        { message: 'hello world' },
+      )
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe(
+        'application/json; charset=utf-8',
+      )
+      expect(res.data?.message).toBe('hello world')
+    })
   })
-})
+}

package/tests/queries.test.ts

@@ -3,9 +3,14 @@ import { AddressInfo } from 'node:net'
 import { LexiconDoc } from '@atproto/lexicon'
 import { XrpcClient } from '@atproto/xrpc'
 import * as xrpcServer from '../src'
-import { closeServer, createServer } from './_util'
+import {
+  buildAddLexicons,
+  buildMethodLexicons,
+  closeServer,
+  createServer,
+} from './_util'
 
-const LEXICONS: LexiconDoc[] = [
+const LEXICONS = [
   {
     lexicon: 1,
     id: 'io.example.pingOne',
@@ -65,59 +70,71 @@ const LEXICONS: LexiconDoc[] = [
       },
     },
   },
-]
+] as const satisfies LexiconDoc[]
 
-describe('Queries', () => {
-  let s: http.Server
-  const server = xrpcServer.createServer(LEXICONS)
-  server.method('io.example.pingOne', (ctx) => {
+const handlers = {
+  'io.example.pingOne': (ctx: xrpcServer.HandlerContext) => {
     return { encoding: 'text/plain', body: ctx.params.message }
-  })
-  server.method('io.example.pingTwo', (ctx) => {
+  },
+  'io.example.pingTwo': (ctx: xrpcServer.HandlerContext) => {
     return {
       encoding: 'application/octet-stream',
       body: new TextEncoder().encode(String(ctx.params.message)),
     }
-  })
-  server.method('io.example.pingThree', (ctx) => {
+  },
+  'io.example.pingThree': (ctx: xrpcServer.HandlerContext) => {
     return {
       encoding: 'application/json',
       body: { message: ctx.params.message },
       headers: { 'x-test-header-name': 'test-value' },
     }
-  })
+  },
+}
 
-  let client: XrpcClient
-  beforeAll(async () => {
-    s = await createServer(server)
-    const { port } = s.address() as AddressInfo
-    client = new XrpcClient(`http://localhost:${port}`, LEXICONS)
-  })
-  afterAll(async () => {
-    await closeServer(s)
-  })
+for (const buildServer of [buildMethodLexicons, buildAddLexicons]) {
+  describe(buildServer, () => {
+    let s: http.Server
+    let client: XrpcClient
+    let url: string
+    beforeAll(async () => {
+      const server = await buildServer(LEXICONS, handlers)
+      s = await createServer(server)
+      const { port } = s.address() as AddressInfo
+      url = `http://localhost:${port}`
+      client = new XrpcClient(url, LEXICONS)
+    })
+    afterAll(async () => {
+      if (s) await closeServer(s)
+    })
 
-  it('serves requests', async () => {
-    const res1 = await client.call('io.example.pingOne', {
-      message: 'hello world',
+    test('io.example.pingOne', async () => {
+      const res = await client.call('io.example.pingOne', {
+        message: 'hello world',
+      })
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe('text/plain; charset=utf-8')
+      expect(res.data).toBe('hello world')
     })
-    expect(res1.success).toBeTruthy()
-    expect(res1.headers['content-type']).toBe('text/plain; charset=utf-8')
-    expect(res1.data).toBe('hello world')
 
-    const res2 = await client.call('io.example.pingTwo', {
-      message: 'hello world',
+    test('io.example.pingTwo', async () => {
+      const res = await client.call('io.example.pingTwo', {
+        message: 'hello world',
+      })
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe('application/octet-stream')
+      expect(new TextDecoder().decode(res.data)).toBe('hello world')
     })
-    expect(res2.success).toBeTruthy()
-    expect(res2.headers['content-type']).toBe('application/octet-stream')
-    expect(new TextDecoder().decode(res2.data)).toBe('hello world')
 
-    const res3 = await client.call('io.example.pingThree', {
-      message: 'hello world',
+    test('io.example.pingThree', async () => {
+      const res = await client.call('io.example.pingThree', {
+        message: 'hello world',
+      })
+      expect(res.success).toBeTruthy()
+      expect(res.headers['content-type']).toBe(
+        'application/json; charset=utf-8',
+      )
+      expect(res.data?.message).toBe('hello world')
+      expect(res.headers['x-test-header-name']).toEqual('test-value')
     })
-    expect(res3.success).toBeTruthy()
-    expect(res3.headers['content-type']).toBe('application/json; charset=utf-8')
-    expect(res3.data?.message).toBe('hello world')
-    expect(res3.headers['x-test-header-name']).toEqual('test-value')
   })
-})
+}