@atproto/pds 0.5.12 → 0.5.15

package/tests/server.test.ts

@@ -1,151 +0,0 @@
-import { finished } from 'node:stream/promises'
-import express from 'express'
-import { request } from 'undici'
-import { AtUri, AtpAgent } from '@atproto/api'
-import { randomStr } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { handler as errorHandler } from '../src/error.js'
-import { startServer } from './_util.js'
-import basicSeed from './seeds/basic.js'
-
-describe('server', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-  let alice: DidString
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'server',
-      pds: {
-        version: '0.0.0',
-      },
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    alice = sc.dids.alice
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('preserves 404s.', async () => {
-    const res = await fetch(`${network.pds.url}/unknown`)
-    expect(res.status).toEqual(404)
-  })
-
-  it('error handler turns unknown errors into 500s.', async () => {
-    const app = express()
-      .get('/oops', () => {
-        throw new Error('Oops!')
-      })
-      .use(errorHandler)
-
-    await using server = await startServer(app)
-
-    const res = await fetch(`http://localhost:${server.port}/oops`)
-    expect(res.status).toEqual(500)
-    await expect(res.json()).resolves.toEqual({
-      error: 'InternalServerError',
-      message: 'Internal Server Error',
-    })
-  })
-
-  it('limits size of json input.', async () => {
-    const res = await fetch(
-      `${network.pds.url}/xrpc/com.atproto.identity.updateHandle`,
-      {
-        method: 'POST',
-        body: '"' + 'x'.repeat(150 * 1024) + '"', // ~150kb
-        headers: {
-          ...sc.getHeaders(alice),
-          'Content-Type': 'application/json',
-        },
-      },
-    )
-
-    expect(res.status).toEqual(413)
-    await expect(res.json()).resolves.toEqual({
-      error: 'PayloadTooLargeError',
-      message: 'request entity too large',
-    })
-  })
-
-  it('compresses large json responses', async () => {
-    // first create a large record
-    const record = {
-      text: 'blahblabh',
-      createdAt: new Date().toISOString(),
-    }
-    for (let i = 0; i < 100; i++) {
-      record[randomStr(8, 'base32')] = randomStr(32, 'base32')
-    }
-    const createRes = await agent.com.atproto.repo.createRecord(
-      {
-        repo: alice,
-        collection: 'app.bsky.feed.post',
-        record,
-      },
-      { headers: sc.getHeaders(alice), encoding: 'application/json' },
-    )
-    const uri = new AtUri(createRes.data.uri)
-
-    const url = new URL(`/xrpc/com.atproto.repo.getRecord`, network.pds.url)
-    url.searchParams.set('repo', uri.host)
-    url.searchParams.set('collection', uri.collectionSafe)
-    url.searchParams.set('rkey', uri.rkeySafe)
-
-    const res = await request(url, {
-      headers: { ...sc.getHeaders(alice), 'accept-encoding': 'gzip' },
-    })
-
-    await finished(res.body.resume())
-
-    expect(res.headers['content-encoding']).toEqual('gzip')
-  })
-
-  it('compresses large car file responses', async () => {
-    const url = new URL(`/xrpc/com.atproto.sync.getRepo`, network.pds.url)
-    url.searchParams.set('did', alice)
-
-    const res = await request(url, {
-      headers: { 'accept-encoding': 'gzip' },
-    })
-
-    await finished(res.body.resume())
-
-    expect(res.headers['content-encoding']).toEqual('gzip')
-  })
-
-  it('does not compress small payloads', async () => {
-    const url = new URL(`/xrpc/_health`, network.pds.url)
-    const res = await request(url, {
-      headers: { 'accept-encoding': 'gzip' },
-    })
-
-    await finished(res.body.resume())
-
-    expect(res.headers['content-encoding']).toBeUndefined()
-  })
-
-  it('healthcheck succeeds when database is available.', async () => {
-    const res = await fetch(`${network.pds.url}/xrpc/_health`)
-    expect(res.status).toEqual(200)
-    await expect(res.json()).resolves.toEqual({ version: '0.0.0' })
-  })
-
-  // @TODO this is hanging for some unknown reason
-  it.skip('healthcheck fails when database is unavailable.', async () => {
-    await network.pds.ctx.accountManager.db.close()
-
-    const response = await fetch(`${network.pds.url}/xrpc/_health`)
-    expect(response.status).toEqual(503)
-    await expect(response.json()).resolves.toEqual({
-      version: 'unknown',
-      error: 'Service Unavailable',
-    })
-  })
-})

package/tests/sync/invertible-ops.test.ts

@@ -1,99 +0,0 @@
-import assert from 'node:assert'
-import { AtUri } from '@atproto/api'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import * as repo from '@atproto/repo'
-import { isValidDid } from '@atproto/syntax'
-import { Subscription } from '@atproto/xrpc-server'
-import { com } from '../../src/lexicons.js'
-import basicSeed from '../seeds/basic.js'
-
-describe('invertible ops', () => {
-  let network: TestNetworkNoAppView
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'repo_invertible_ops',
-    })
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-
-    let posts: AtUri[] = []
-    for (let i = 0; i < 20; i++) {
-      const [aliceRef, bobRef, carolRef, danRef] = await Promise.all([
-        sc.post(sc.dids.alice, 'test'),
-        sc.post(sc.dids.bob, 'test'),
-        sc.post(sc.dids.carol, 'test'),
-        sc.post(sc.dids.dan, 'test'),
-      ])
-      posts = [
-        ...posts,
-        aliceRef.ref.uri,
-        bobRef.ref.uri,
-        carolRef.ref.uri,
-        danRef.ref.uri,
-      ]
-    }
-    for (const post of posts) {
-      assert(isValidDid(post.hostname))
-      await sc.deletePost(post.hostname, post)
-    }
-
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('works', async () => {
-    const currSeq = (await network.pds.ctx.sequencer.curr()) ?? 0
-
-    const sub = new Subscription({
-      service: network.pds.url.replace('http://', 'ws://'),
-      method: 'com.atproto.sync.subscribeRepos',
-      validate: (value: unknown) => {
-        return com.atproto.sync.subscribeRepos.$message.parse(value)
-      },
-      getParams: () => {
-        return { cursor: 0 }
-      },
-    })
-
-    for await (const evt of sub) {
-      if (!com.atproto.sync.subscribeRepos.commit.$isTypeOf(evt)) {
-        continue
-      }
-
-      const { prevData } = evt
-      if (!prevData) continue
-
-      const { blocks, root } = await repo.readCarWithRoot(evt.blocks)
-      const storage = new repo.MemoryBlockstore(blocks)
-      const slice = await repo.Repo.load(storage, root)
-
-      let data = slice.data
-      const ops = evt.ops
-      for (const op of ops) {
-        if (op.action === 'create') {
-          data = await data.delete(op.path)
-        } else if (op.action === 'update') {
-          if (!op.prev) throw new Error('missing prev')
-          data = await data.update(op.path, op.prev)
-        } else if (op.action === 'delete') {
-          if (!op.prev) throw new Error('missing prev')
-          data = await data.add(op.path, op.prev)
-        } else {
-          throw new Error('unknown action')
-        }
-      }
-
-      const invertedRoot = await data.getPointer()
-      expect(invertedRoot.equals(prevData)).toBe(true)
-
-      if (evt.seq >= currSeq) {
-        break
-      }
-    }
-  })
-})

package/tests/sync/list.test.ts

@@ -1,43 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import basicSeed from '../seeds/basic.js'
-
-describe('sync listing', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'sync_list',
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('lists hosted repos in order of creation', async () => {
-    const res = await agent.api.com.atproto.sync.listRepos()
-    const dids = res.data.repos.map((repo) => repo.did)
-    expect(dids).toEqual([
-      sc.dids.alice,
-      sc.dids.bob,
-      sc.dids.carol,
-      sc.dids.dan,
-    ])
-    expect(res.data.repos.every((r) => r.active === true)).toBe(true)
-  })
-
-  it('paginates listed hosted repos', async () => {
-    const full = await agent.api.com.atproto.sync.listRepos()
-    const pt1 = await agent.api.com.atproto.sync.listRepos({ limit: 2 })
-    const pt2 = await agent.api.com.atproto.sync.listRepos({
-      cursor: pt1.data.cursor,
-    })
-    expect([...pt1.data.repos, ...pt2.data.repos]).toEqual(full.data.repos)
-  })
-})