@atproto/pds 0.5.12 → 0.5.15

package/tests/crud.test.ts

@@ -1,1595 +0,0 @@
-import assert from 'node:assert'
-import fs from 'node:fs/promises'
-import {
-  AppBskyEmbedImages,
-  AppBskyFeedPost,
-  AppBskyFeedPostRecord,
-  AtpAgent,
-  BlobRef,
-} from '@atproto/api'
-import { TID, cidForCbor, ui8ToArrayBuffer } from '@atproto/common'
-import { TestNetworkNoAppView } from '@atproto/dev-env'
-import { BlobNotFoundError } from '@atproto/repo'
-import { AtUri } from '@atproto/syntax'
-import { AppContext } from '../src/context.js'
-import { forSnapshot, paginateAll } from './_util.js'
-
-describe('crud operations', () => {
-  let network: TestNetworkNoAppView
-  let ctx: AppContext
-  let agent: AtpAgent
-  let aliceAgent: AtpAgent
-  let bobAgent: AtpAgent
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'crud',
-    })
-    // @ts-expect-error Error due to circular dependency with the dev-env package
-    ctx = network.pds.ctx
-    agent = network.pds.getAgent()
-    aliceAgent = network.pds.getAgent()
-    bobAgent = network.pds.getAgent()
-
-    await aliceAgent.createAccount({
-      email: 'alice@test.com',
-      handle: 'alice.test',
-      password: 'alice-pass',
-    })
-
-    await bobAgent.createAccount({
-      email: 'bob@test.com',
-      handle: 'bob.test',
-      password: 'bob-pass',
-    })
-
-    expect(bobAgent.assertDid).not.toBe(aliceAgent.assertDid)
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('registers users', async () => {
-    const res = await agent.com.atproto.server.createAccount({
-      handle: 'user1.test',
-      email: 'user1@test.com',
-      password: 'password',
-    })
-    expect(res.data.handle).toBe('user1.test')
-    expect(res.data.accessJwt).toBeDefined()
-  })
-
-  it('describes repo', async () => {
-    const description = await agent.com.atproto.repo.describeRepo({
-      repo: aliceAgent.assertDid,
-    })
-    expect(description.data.handle).toBe('alice.test')
-    expect(description.data.did).toBe(aliceAgent.assertDid)
-    const description2 = await agent.com.atproto.repo.describeRepo({
-      repo: bobAgent.assertDid,
-    })
-    expect(description2.data.handle).toBe('bob.test')
-    expect(description2.data.did).toBe(bobAgent.assertDid)
-  })
-
-  it('creates records', async () => {
-    const res = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-      record: {
-        $type: 'app.bsky.feed.post',
-        text: 'Hello, world!',
-        createdAt: new Date().toISOString(),
-      },
-    })
-    const uri = new AtUri(res.data.uri)
-    expect(res.data.uri).toBe(
-      `at://${aliceAgent.assertDid}/app.bsky.feed.post/${uri.rkey}`,
-    )
-
-    const res1 = await agent.com.atproto.repo.listRecords({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-    })
-    expect(res1.data.records.length).toBe(1)
-    expect(res1.data.records[0].uri).toBe(uri.toString())
-    const { value } = res1.data.records[0]
-    assert(AppBskyFeedPost.isMain(value))
-    expect(value.text).toBe('Hello, world!')
-
-    const res2 = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(res2.records.length).toBe(1)
-    expect(res2.records[0].uri).toBe(uri.toString())
-    expect(res2.records[0].value.text).toBe('Hello, world!')
-
-    const res3 = await agent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-      rkey: uri.rkey,
-    })
-    expect(res3.data.uri).toBe(uri.toString())
-    assert(AppBskyFeedPost.isMain(res3.data.value))
-    expect(res3.data.value.text).toBe('Hello, world!')
-
-    const res4 = await agent.app.bsky.feed.post.get({
-      repo: aliceAgent.assertDid,
-      rkey: uri.rkey,
-    })
-    expect(res4.uri).toBe(uri.toString())
-    expect(res4.value.text).toBe('Hello, world!')
-
-    await aliceAgent.com.atproto.repo.deleteRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-      rkey: uri.rkey,
-    })
-    const res5 = await agent.com.atproto.repo.listRecords({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-    })
-    expect(res5.data.records.length).toBe(0)
-  })
-
-  it('CRUDs records with the semantic sugars', async () => {
-    const res1 = await aliceAgent.app.bsky.feed.post.create(
-      { repo: aliceAgent.assertDid },
-      {
-        $type: 'app.bsky.feed.post',
-        text: 'Hello, world!',
-        createdAt: new Date().toISOString(),
-      },
-    )
-    const uri = new AtUri(res1.uri)
-
-    const res2 = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(res2.records.length).toBe(1)
-
-    await aliceAgent.app.bsky.feed.post.delete({
-      repo: aliceAgent.assertDid,
-      rkey: uri.rkey,
-    })
-
-    const res3 = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(res3.records.length).toBe(0)
-  })
-
-  it('attaches images to a post', async () => {
-    const file = await fs.readFile('../dev-env/assets/key-landscape-small.jpg')
-    const uploadedRes = await aliceAgent.com.atproto.repo.uploadBlob(file, {
-      encoding: 'image/jpeg',
-    })
-    const uploaded = uploadedRes.data.blob
-    // Expect blobstore not to have image yet
-    await expect(
-      ctx.blobstore(aliceAgent.assertDid).getBytes(uploaded.ref),
-    ).rejects.toThrow(BlobNotFoundError)
-    // Associate image with post, image should be placed in blobstore
-    const res = await aliceAgent.app.bsky.feed.post.create(
-      { repo: aliceAgent.assertDid },
-      {
-        $type: 'app.bsky.feed.post',
-        text: "Here's a key!",
-        createdAt: new Date().toISOString(),
-        embed: {
-          $type: 'app.bsky.embed.images',
-          images: [{ image: uploaded, alt: '' }],
-        },
-      },
-    )
-    // Ensure image is on post record
-    const postUri = new AtUri(res.uri)
-    const post = await aliceAgent.app.bsky.feed.post.get({
-      rkey: postUri.rkey,
-      repo: aliceAgent.assertDid,
-    })
-    assert(AppBskyEmbedImages.isMain(post.value.embed))
-    const images = post.value.embed.images
-    expect(images.length).toEqual(1)
-    expect(uploaded.ref.equals(images[0].image.ref)).toBeTruthy()
-    // Ensure that the uploaded image is now in the blobstore, i.e. doesn't throw BlobNotFoundError
-    await ctx.blobstore(aliceAgent.assertDid).getBytes(uploaded.ref)
-    // Cleanup
-    await aliceAgent.app.bsky.feed.post.delete({
-      rkey: postUri.rkey,
-      repo: aliceAgent.assertDid,
-    })
-  })
-
-  it('creates records with the correct key described by the schema', async () => {
-    const res1 = await aliceAgent.app.bsky.actor.profile.create(
-      { repo: aliceAgent.assertDid },
-      {
-        displayName: 'alice',
-        createdAt: new Date().toISOString(),
-      },
-    )
-    const uri = new AtUri(res1.uri)
-    expect(uri.rkey).toBe('self')
-  })
-
-  describe('paginates', () => {
-    let uri1: AtUri
-    let uri2: AtUri
-    let uri3: AtUri
-    let uri4: AtUri
-    let uri5: AtUri
-
-    beforeAll(async () => {
-      const createPost = async (text: string) => {
-        const res = await aliceAgent.app.bsky.feed.post.create(
-          { repo: aliceAgent.assertDid },
-          {
-            $type: 'app.bsky.feed.post',
-            text,
-            createdAt: new Date().toISOString(),
-          },
-        )
-        return new AtUri(res.uri)
-      }
-      uri1 = await createPost('Post 1')
-      uri2 = await createPost('Post 2')
-      uri3 = await createPost('Post 3')
-      uri4 = await createPost('Post 4')
-      uri5 = await createPost('Post 5')
-    })
-
-    afterAll(async () => {
-      for (const uri of [uri1, uri2, uri3, uri4, uri5]) {
-        await aliceAgent.app.bsky.feed.post.delete({
-          repo: aliceAgent.assertDid,
-          rkey: uri.rkey,
-        })
-      }
-    })
-
-    it('in forwards order', async () => {
-      const paginator = async (cursor?: string) => {
-        return agent.app.bsky.feed.post.list({
-          repo: aliceAgent.assertDid,
-          cursor,
-          limit: 2,
-        })
-      }
-
-      const paginatedAll = await paginateAll(paginator)
-      paginatedAll.forEach((res) =>
-        expect(res.records.length).toBeLessThanOrEqual(2),
-      )
-
-      const full = await agent.app.bsky.feed.post.list({
-        repo: aliceAgent.assertDid,
-      })
-
-      expect(full.records.length).toEqual(5)
-      expect(paginatedAll.flatMap((res) => res.records)).toEqual(full.records)
-    })
-
-    it('in reverse order', async () => {
-      const results = (
-        results: Awaited<ReturnType<AppBskyFeedPostRecord['list']>>[],
-      ) => results.flatMap((res) => res.records)
-      const paginator = async (cursor?: string) => {
-        const res = await agent.app.bsky.feed.post.list({
-          repo: aliceAgent.assertDid,
-          reverse: true,
-          cursor,
-          limit: 2,
-        })
-        return res
-      }
-
-      const paginatedAll = await paginateAll(paginator)
-      paginatedAll.forEach((res) =>
-        expect(res.records.length).toBeLessThanOrEqual(2),
-      )
-
-      const full = await agent.app.bsky.feed.post.list({
-        repo: aliceAgent.assertDid,
-        reverse: true,
-      })
-
-      expect(full.records.length).toEqual(5)
-      expect(results(paginatedAll)).toEqual(results([full]))
-    })
-
-    it('reverses', async () => {
-      const forwards = await agent.app.bsky.feed.post.list({
-        repo: aliceAgent.assertDid,
-      })
-      const reverse = await agent.app.bsky.feed.post.list({
-        repo: aliceAgent.assertDid,
-        reverse: true,
-      })
-      expect(forwards.cursor).toEqual(uri1.rkey)
-      expect(reverse.cursor).toEqual(uri5.rkey)
-      expect(forwards.records.length).toEqual(5)
-      expect(reverse.records.length).toEqual(5)
-      expect(forwards.records.reverse()).toEqual(reverse.records)
-    })
-  })
-
-  describe('deleteRecord', () => {
-    it('deletes a record if it exists', async () => {
-      const { repo } = aliceAgent.com.atproto
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: { text: 'post', createdAt: new Date().toISOString() },
-      })
-      const uri = new AtUri(post.uri)
-      await repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).rejects.toThrow('Could not locate record')
-    })
-
-    it("no-ops if record doesn't exist", async () => {
-      const { repo } = aliceAgent.com.atproto
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: { text: 'post', createdAt: new Date().toISOString() },
-      })
-      const uri = new AtUri(post.uri)
-      await repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).rejects.toThrow('Could not locate record')
-      const attemptDelete = repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(attemptDelete).resolves.toBeDefined()
-    })
-
-    it('does not delete the underlying block if it is referenced elsewhere', async () => {
-      const { repo } = aliceAgent.com.atproto
-      const record = { text: 'post', createdAt: new Date().toISOString() }
-      const { data: post1 } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record,
-      })
-      const { data: post2 } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record,
-      })
-      const uri1 = new AtUri(post1.uri)
-      await repo.deleteRecord({
-        repo: uri1.host,
-        collection: uri1.collection,
-        rkey: uri1.rkey,
-      })
-      const uri2 = new AtUri(post2.uri)
-      const checkPost2 = await repo.getRecord({
-        repo: uri2.host,
-        collection: uri2.collection,
-        rkey: uri2.rkey,
-      })
-      expect(checkPost2).toBeDefined()
-      expect(checkPost2.data.value).toMatchObject(record)
-    })
-  })
-
-  describe('putRecord', () => {
-    const profilePath = {
-      collection: 'app.bsky.actor.profile',
-      rkey: 'self',
-    }
-
-    it("creates a new record if it doesn't already exist", async () => {
-      const { repo } = bobAgent.com.atproto
-      const exists = repo.getRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-      })
-      await expect(exists).rejects.toThrow('Could not locate record')
-
-      const { data: put } = await repo.putRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-        record: {
-          displayName: 'Robert',
-        },
-      })
-      expect(put.uri).toEqual(
-        `at://${bobAgent.assertDid}/app.bsky.actor.profile/self`,
-      )
-
-      const { data: profile } = await repo.getRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-      })
-      expect(profile.value).toEqual({
-        $type: 'app.bsky.actor.profile',
-        displayName: 'Robert',
-      })
-    })
-
-    it('updates a record if it already exists', async () => {
-      const { repo } = bobAgent.com.atproto
-      const { data: put } = await repo.putRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-        record: {
-          displayName: 'Robert',
-          description: 'Dog lover',
-        },
-      })
-      expect(put.uri).toEqual(
-        `at://${bobAgent.assertDid}/app.bsky.actor.profile/self`,
-      )
-
-      const { data: profile } = await repo.getRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-      })
-      expect(profile.value).toEqual({
-        $type: 'app.bsky.actor.profile',
-        displayName: 'Robert',
-        description: 'Dog lover',
-      })
-    })
-
-    it('still works if repo is specified by handle', async () => {
-      await bobAgent.com.atproto.repo.putRecord({
-        repo: 'bob.test',
-        collection: 'app.bsky.graph.follow',
-        rkey: TID.nextStr(),
-        record: {
-          subject: aliceAgent.assertDid,
-          createdAt: new Date().toISOString(),
-        },
-      })
-    })
-
-    it('does not produce commit on no-op update', async () => {
-      const { repo } = bobAgent.com.atproto
-      const rootRes1 = await bobAgent.com.atproto.sync.getLatestCommit({
-        did: bobAgent.assertDid,
-      })
-      const { data: put } = await repo.putRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-        record: {
-          displayName: 'Robert',
-          description: 'Dog lover',
-        },
-      })
-      expect(put.uri).toEqual(
-        `at://${bobAgent.assertDid}/app.bsky.actor.profile/self`,
-      )
-
-      const rootRes2 = await bobAgent.com.atproto.sync.getLatestCommit({
-        did: bobAgent.assertDid,
-      })
-
-      expect(rootRes2.data.cid).toEqual(rootRes1.data.cid)
-      expect(rootRes2.data.rev).toEqual(rootRes1.data.rev)
-    })
-
-    it('fails on user mismatch', async () => {
-      const { repo } = aliceAgent.com.atproto
-      const put = repo.putRecord({
-        repo: bobAgent.assertDid,
-        collection: 'app.bsky.graph.follow',
-        rkey: TID.nextStr(),
-        record: {
-          subject: aliceAgent.assertDid,
-          createdAt: new Date().toISOString(),
-        },
-      })
-      await expect(put).rejects.toThrow('Authentication Required')
-    })
-
-    it('fails on invalid record', async () => {
-      const { repo } = bobAgent.com.atproto
-      const put = repo.putRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-        record: {
-          displayName: 'Robert',
-          description: 3.141,
-        },
-      })
-      await expect(put).rejects.toMatchObject({
-        error: 'InvalidRequest',
-        message: expect.stringContaining('description'),
-        // Invalid app.bsky.actor.profile record: Record/description must be a string
-        // Expected one of null, boolean, integer, string, cid, bytes, array or object value type at $.record.description (got float)
-      })
-      const { data: profile } = await repo.getRecord({
-        ...profilePath,
-        repo: bobAgent.assertDid,
-      })
-      expect(profile.value).toEqual({
-        $type: 'app.bsky.actor.profile',
-        displayName: 'Robert',
-        description: 'Dog lover',
-      })
-    })
-
-    // @TODO remove after migrating legacy blobs
-    it('updates a legacy blob ref when updating profile', async () => {
-      const { repo } = bobAgent.api.com.atproto
-      const file = await fs.readFile('../dev-env/assets/key-portrait-small.jpg')
-      const uploadedRes = await repo.uploadBlob(file, {
-        encoding: 'image/jpeg',
-      })
-
-      await repo.putRecord({
-        ...profilePath,
-        repo: bobAgent.accountDid,
-        record: {
-          displayName: 'Robert',
-          avatar: BlobRef.fromJsonRef({
-            mimeType: uploadedRes.data.blob.mimeType,
-            cid: uploadedRes.data.blob.ref.toString(),
-          }),
-        },
-      })
-
-      const got = await repo.getRecord({
-        ...profilePath,
-        repo: bobAgent.accountDid,
-      })
-      const gotAvatar = got.data.value['avatar'] as BlobRef
-      expect(gotAvatar.original).toEqual(uploadedRes.data.blob.original)
-    })
-  })
-
-  // Validation
-  // --------------
-
-  it('defaults an undefined $type on records', async () => {
-    const res = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.post',
-      record: {
-        text: 'blah',
-        createdAt: new Date().toISOString(),
-      },
-    })
-    const uri = new AtUri(res.data.uri)
-    const got = await agent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: uri.collection,
-      rkey: uri.rkey,
-    })
-    expect(got.data.value['$type']).toBe(uri.collection)
-  })
-
-  it('requires the schema to be known if explicitly validating', async () => {
-    const prom = aliceAgent.com.atproto.repo.createRecord({
-      validate: true,
-      repo: aliceAgent.assertDid,
-      collection: 'com.example.foobar',
-      record: { $type: 'com.example.foobar' },
-    })
-    await expect(prom).rejects.toMatchObject({
-      message: expect.stringContaining('com.example.foobar'),
-      // Lexicon not found: lex:com.example.foobar
-      // Unknown lexicon type: com.example.foobar
-    })
-  })
-
-  it('does not require the schema to be known if not explicitly validating', async () => {
-    const prom = await aliceAgent.com.atproto.repo.createRecord({
-      // validate not set
-      repo: aliceAgent.assertDid,
-      collection: 'com.example.foobar',
-      record: { $type: 'com.example.foobar' },
-    })
-    expect(prom.data.validationStatus).toBe('unknown')
-  })
-
-  it('requires the $type to match the schema', async () => {
-    await expect(
-      aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: { $type: 'app.bsky.feed.like' },
-      }),
-    ).rejects.toThrow(
-      'Invalid $type: expected app.bsky.feed.post, got app.bsky.feed.like',
-    )
-  })
-
-  it('requires valid rkey', async () => {
-    await expect(
-      aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.generator',
-        record: {
-          $type: 'app.bsky.feed.generator',
-          did: 'did:web:dummy.example.com',
-          displayName: 'dummy',
-          createdAt: new Date().toISOString(),
-        },
-        rkey: '..',
-      }),
-    ).rejects.toMatchObject({
-      error: 'InvalidRequest',
-      message: expect.stringContaining('rkey'),
-      // Input/rkey must be a valid Record Key
-      // Invalid record key at $.rkey (got \"..\")
-    })
-  })
-
-  it('validates the record on write', async () => {
-    await expect(
-      aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: { $type: 'app.bsky.feed.post' },
-      }),
-    ).rejects.toMatchObject({
-      error: 'InvalidRequest',
-      message: expect.stringContaining('Invalid app.bsky.feed.post record'),
-      // Invalid app.bsky.feed.post record: Record must have the property "text"
-      // Invalid app.bsky.feed.post record: Missing required key \"text\" at $.record
-    })
-  })
-
-  it('validates datetimes rigorously', async () => {
-    const postRecord = {
-      $type: 'app.bsky.feed.post',
-      text: 'test',
-      createdAt: '0000-00-12T23:20:50.123Z',
-    }
-    await expect(
-      aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord,
-      }),
-    ).rejects.toMatchObject({
-      error: 'InvalidRequest',
-      message: expect.stringContaining('Invalid app.bsky.feed.post record'),
-      // Invalid app.bsky.feed.post record: createdAt must be an valid atproto datetime (both RFC-3339 and ISO-8601)
-    })
-  })
-
-  describe('unvalidated writes', () => {
-    it('disallows creation of unknown lexicons when validate is set to true', async () => {
-      const attempt = aliceAgent.com.atproto.repo.createRecord({
-        validate: true,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing',
-        },
-      })
-      await expect(attempt).rejects.toMatchObject({
-        error: 'InvalidRequest',
-        message: expect.stringContaining('com.example.record'),
-        // Lexicon not found: lex:com.example.record
-        // Unknown lexicon type: com.example.record
-      })
-    })
-
-    it('allows creation of unknown lexicons when validate is not set to true', async () => {
-      // validate: default
-      const res1 = await aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing1',
-        },
-      })
-      expect(res1.data.validationStatus).toBe('unknown')
-      const record1 = await ctx.actorStore.read(aliceAgent.assertDid, (store) =>
-        store.record.getRecord(new AtUri(res1.data.uri), res1.data.cid),
-      )
-      expect(record1?.value).toEqual({
-        $type: 'com.example.record',
-        blah: 'thing1',
-      })
-      // validate: false
-      const res2 = await aliceAgent.com.atproto.repo.createRecord({
-        validate: false,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing2',
-        },
-      })
-      expect(res2.data.validationStatus).toBeUndefined()
-      const record2 = await ctx.actorStore.read(aliceAgent.assertDid, (store) =>
-        store.record.getRecord(new AtUri(res2.data.uri), res2.data.cid),
-      )
-      expect(record2?.value).toEqual({
-        $type: 'com.example.record',
-        blah: 'thing2',
-      })
-    })
-
-    it('allows update of unknown lexicons when validate is set to false', async () => {
-      const createRes = await aliceAgent.com.atproto.repo.createRecord({
-        validate: false,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing',
-        },
-      })
-      const uri = new AtUri(createRes.data.uri)
-      // validate: default
-      const updateRes1 = await aliceAgent.com.atproto.repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        rkey: uri.rkey,
-        record: {
-          blah: 'something else',
-        },
-      })
-      const record1 = await ctx.actorStore.read(aliceAgent.assertDid, (store) =>
-        store.record.getRecord(uri, updateRes1.data.cid),
-      )
-      expect(record1?.value).toEqual({
-        $type: 'com.example.record',
-        blah: 'something else',
-      })
-      // validate: false
-      const updateRes2 = await aliceAgent.com.atproto.repo.putRecord({
-        validate: false,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        rkey: uri.rkey,
-        record: {
-          blah: 'something else',
-        },
-      })
-      const record2 = await ctx.actorStore.read(aliceAgent.assertDid, (store) =>
-        store.record.getRecord(uri, updateRes2.data.cid),
-      )
-      expect(record2?.value).toEqual({
-        $type: 'com.example.record',
-        blah: 'something else',
-      })
-    })
-
-    it('applyWrites returns results with validation status', async () => {
-      const existing1 = await aliceAgent.com.atproto.repo.createRecord({
-        validate: false,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing1',
-        },
-      })
-      const existing1Uri = new AtUri(existing1.data.uri)
-      const existing2 = await aliceAgent.com.atproto.repo.createRecord({
-        validate: false,
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing2',
-        },
-      })
-      const existing2Uri = new AtUri(existing2.data.uri)
-      const {
-        data: { results },
-      } = await aliceAgent.com.atproto.repo.applyWrites({
-        repo: aliceAgent.assertDid,
-        writes: [
-          {
-            $type: 'com.atproto.repo.applyWrites#create',
-            collection: 'app.bsky.feed.post',
-            value: {
-              $type: 'app.bsky.feed.post',
-              text: '👋',
-              createdAt: new Date().toISOString(),
-            },
-          },
-          {
-            $type: 'com.atproto.repo.applyWrites#update',
-            collection: existing1Uri.collectionSafe,
-            rkey: existing1Uri.rkey,
-            value: {},
-          },
-          {
-            $type: `com.atproto.repo.applyWrites#delete`,
-            collection: existing2Uri.collectionSafe,
-            rkey: existing2Uri.rkey,
-          },
-        ],
-      })
-      expect(forSnapshot(results)).toEqual([
-        {
-          $type: `com.atproto.repo.applyWrites#createResult`,
-          cid: 'cids(0)',
-          uri: 'record(0)',
-          validationStatus: 'valid',
-        },
-        {
-          $type: `com.atproto.repo.applyWrites#updateResult`,
-          cid: 'cids(1)',
-          uri: 'record(1)',
-          validationStatus: 'unknown',
-        },
-        { $type: `com.atproto.repo.applyWrites#deleteResult` },
-      ])
-    })
-
-    it('correctly associates images with unknown record types', async () => {
-      const file = await fs.readFile('../dev-env/assets/key-portrait-small.jpg')
-      const uploadedRes = await aliceAgent.com.atproto.repo.uploadBlob(file, {
-        encoding: 'image/jpeg',
-      })
-
-      const res = await aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          blah: 'thing',
-          image: uploadedRes.data.blob,
-        },
-        validate: false,
-      })
-      const record = await ctx.actorStore.read(aliceAgent.assertDid, (store) =>
-        store.record.getRecord(new AtUri(res.data.uri), res.data.cid),
-      )
-      assert(record)
-      expect(record.value).toMatchObject({
-        $type: 'com.example.record',
-        blah: 'thing',
-      })
-      const recordBlobs = await ctx.actorStore.read(
-        aliceAgent.assertDid,
-        (store) => store.repo.blob.getBlobsForRecord(record.uri),
-      )
-      expect(recordBlobs.length).toBe(1)
-      expect(recordBlobs.at(0)).toBe(uploadedRes.data.blob.ref.toString())
-    })
-
-    it('enforces record type constraint even when unvalidated', async () => {
-      const attempt = aliceAgent.com.atproto.repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'com.example.record',
-        record: {
-          $type: 'com.example.other',
-          blah: 'thing',
-        },
-      })
-      await expect(attempt).rejects.toThrow(
-        'Invalid $type: expected com.example.record, got com.example.other',
-      )
-    })
-
-    it('enforces blob ref format even when unvalidated', async () => {
-      const file = await fs.readFile('../dev-env/assets/key-portrait-small.jpg')
-      const uploadedRes = await aliceAgent.com.atproto.repo.uploadBlob(file, {
-        encoding: 'image/jpeg',
-      })
-
-      await expect(
-        aliceAgent.com.atproto.repo.createRecord({
-          repo: aliceAgent.assertDid,
-          collection: 'com.example.record',
-          record: {
-            blah: 'thing',
-            image: {
-              cid: uploadedRes.data.blob.ref.toString(),
-              mimeType: uploadedRes.data.blob.mimeType,
-            },
-          },
-          validate: false,
-        }),
-      ).rejects.toMatchObject({
-        error: 'InvalidRequest',
-        message: expect.stringContaining('Legacy blobs are not allowed'),
-      })
-    })
-  })
-
-  describe('compare-and-swap', () => {
-    let recordCount = 0 // Ensures unique cids
-    const postRecord = () => ({
-      text: `post (${++recordCount})`,
-      createdAt: new Date().toISOString(),
-    })
-    const profileRecord = () => ({
-      displayName: `ali (${++recordCount})`,
-    })
-
-    it('createRecord succeeds on proper commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: commit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        swapCommit: commit.cid,
-        record: postRecord(),
-      })
-      const uri = new AtUri(post.uri)
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).resolves.toBeDefined()
-    })
-
-    it('createRecord fails on bad commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: staleCommit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      // Update repo, change head
-      await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const attemptCreate = repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        swapCommit: staleCommit.cid,
-        record: postRecord(),
-      })
-      await expect(attemptCreate).rejects.toMatchObject({
-        error: 'InvalidSwap',
-      })
-    })
-
-    it('deleteRecord succeeds on proper commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const { data: commit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      const uri = new AtUri(post.uri)
-      await repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-        swapCommit: commit.cid,
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).rejects.toThrow('Could not locate record')
-    })
-
-    it('deleteRecord fails on bad commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: staleCommit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const uri = new AtUri(post.uri)
-      const attemptDelete = repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-        swapCommit: staleCommit.cid,
-      })
-      await expect(attemptDelete).rejects.toMatchObject({
-        error: 'InvalidSwap',
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).resolves.toBeDefined()
-    })
-
-    it('deleteRecord succeeds on proper record cas', async () => {
-      const { repo } = aliceAgent.com.atproto
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const uri = new AtUri(post.uri)
-      await repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-        swapRecord: post.cid,
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).rejects.toThrow('Could not locate record')
-    })
-
-    it('deleteRecord fails on bad record cas', async () => {
-      const { repo } = aliceAgent.com.atproto
-      const { data: post } = await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const uri = new AtUri(post.uri)
-      const attemptDelete = repo.deleteRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-        swapRecord: (await cidForCbor({})).toString(),
-      })
-      await expect(attemptDelete).rejects.toMatchObject({
-        error: 'InvalidSwap',
-      })
-      const checkPost = repo.getRecord({
-        repo: uri.host,
-        collection: uri.collection,
-        rkey: uri.rkey,
-      })
-      await expect(checkPost).resolves.toBeDefined()
-    })
-
-    it('putRecord succeeds on proper commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: commit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      const { data: profile } = await repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapCommit: commit.cid,
-        record: profileRecord(),
-      })
-      const { data: checkProfile } = await repo.getRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-      expect(checkProfile.cid).toEqual(profile.cid)
-    })
-
-    it('putRecord fails on bad commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: staleCommit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      // Update repo, change head
-      await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const attemptPut = repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapCommit: staleCommit.cid,
-        record: profileRecord(),
-      })
-      await expect(attemptPut).rejects.toMatchObject({ error: 'InvalidSwap' })
-    })
-
-    it('putRecord succeeds on proper record cas', async () => {
-      const { repo } = aliceAgent.com.atproto
-      // Start with missing profile record, to test swapRecord=null
-      await repo.deleteRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-      // Test swapRecord w/ null (ensures create)
-      const { data: profile1 } = await repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapRecord: null,
-        record: profileRecord(),
-      })
-      const { data: checkProfile1 } = await repo.getRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-      expect(checkProfile1.cid).toEqual(profile1.cid)
-      // Test swapRecord w/ cid (ensures update)
-      const { data: profile2 } = await repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapRecord: profile1.cid,
-        record: profileRecord(),
-      })
-      const { data: checkProfile2 } = await repo.getRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-      expect(checkProfile2.cid).toEqual(profile2.cid)
-    })
-
-    it('putRecord fails on bad record cas', async () => {
-      const { repo } = aliceAgent.com.atproto
-      // Test swapRecord w/ null (ensures create)
-      const attemptPut1 = repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapRecord: null,
-        record: profileRecord(),
-      })
-      await expect(attemptPut1).rejects.toMatchObject({ error: 'InvalidSwap' })
-      // Test swapRecord w/ cid (ensures update)
-      const attemptPut2 = repo.putRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-        swapRecord: (await cidForCbor({})).toString(),
-        record: profileRecord(),
-      })
-      await expect(attemptPut2).rejects.toMatchObject({ error: 'InvalidSwap' })
-    })
-
-    it('applyWrites succeeds on proper commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: commit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      await repo.applyWrites({
-        repo: aliceAgent.assertDid,
-        swapCommit: commit.cid,
-        writes: [
-          {
-            $type: `com.atproto.repo.applyWrites#create`,
-            collection: 'app.bsky.feed.post',
-            value: { $type: 'app.bsky.feed.post', ...postRecord() },
-          },
-        ],
-      })
-    })
-
-    it('applyWrites fails on bad commit cas', async () => {
-      const { repo, sync } = aliceAgent.com.atproto
-      const { data: staleCommit } = await sync.getLatestCommit({
-        did: aliceAgent.assertDid,
-      })
-      // Update repo, change head
-      await repo.createRecord({
-        repo: aliceAgent.assertDid,
-        collection: 'app.bsky.feed.post',
-        record: postRecord(),
-      })
-      const attemptApplyWrite = repo.applyWrites({
-        repo: aliceAgent.assertDid,
-        swapCommit: staleCommit.cid,
-        writes: [
-          {
-            $type: `com.atproto.repo.applyWrites#create`,
-            collection: 'app.bsky.feed.post',
-            value: { $type: 'app.bsky.feed.post', ...postRecord() },
-          },
-        ],
-      })
-      await expect(attemptApplyWrite).rejects.toMatchObject({
-        error: 'InvalidSwap',
-      })
-    })
-
-    it("writes fail on values that can't reliably transform between cbor to lex", async () => {
-      const passthroughBody = (data: unknown) =>
-        ui8ToArrayBuffer(new TextEncoder().encode(JSON.stringify(data)))
-
-      const result = aliceAgent.call(
-        'com.atproto.repo.createRecord',
-        {},
-        passthroughBody({
-          repo: aliceAgent.assertDid,
-          collection: 'app.bsky.feed.post',
-          record: {
-            text: 'x',
-            createdAt: new Date().toISOString(),
-            deepObject: createDeepObject(4000),
-          },
-        }),
-        {
-          encoding: 'application/json',
-        },
-      )
-
-      await expect(result).rejects.toMatchObject({
-        status: 400,
-        error: 'InvalidRequest',
-      })
-    })
-  })
-
-  it('prevents duplicate likes', async () => {
-    const now = new Date().toISOString()
-    const uriA = AtUri.make(
-      bobAgent.assertDid,
-      'app.bsky.feed.post',
-      TID.nextStr(),
-    )
-    const cidA = await cidForCbor({ post: 'a' })
-    const uriB = AtUri.make(
-      bobAgent.assertDid,
-      'app.bsky.feed.post',
-      TID.nextStr(),
-    )
-    const cidB = await cidForCbor({ post: 'b' })
-
-    const { data: like1 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      record: {
-        $type: 'app.bsky.feed.like',
-        subject: { uri: uriA.toString(), cid: cidA.toString() },
-        createdAt: now,
-      },
-    })
-    const { data: like2 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      record: {
-        $type: 'app.bsky.feed.like',
-        subject: { uri: uriB.toString(), cid: cidB.toString() },
-        createdAt: now,
-      },
-    })
-    const { data: like3 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      record: {
-        $type: 'app.bsky.feed.like',
-        subject: { uri: uriA.toString(), cid: cidA.toString() },
-        createdAt: now,
-      },
-    })
-
-    const getLike1 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      rkey: new AtUri(like1.uri).rkey,
-    })
-
-    await expect(getLike1).rejects.toThrow('Could not locate record:')
-
-    const getLike2 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      rkey: new AtUri(like2.uri).rkey,
-    })
-
-    await expect(getLike2).resolves.toBeDefined()
-
-    const getLike3 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.like',
-      rkey: new AtUri(like3.uri).rkey,
-    })
-
-    await expect(getLike3).resolves.toBeDefined()
-  })
-
-  it('prevents duplicate reposts', async () => {
-    const now = new Date().toISOString()
-    const uriA = AtUri.make(
-      bobAgent.assertDid,
-      'app.bsky.feed.post',
-      TID.nextStr(),
-    )
-    const cidA = await cidForCbor({ post: 'a' })
-    const uriB = AtUri.make(
-      bobAgent.assertDid,
-      'app.bsky.feed.post',
-      TID.nextStr(),
-    )
-    const cidB = await cidForCbor({ post: 'b' })
-
-    const { data: repost1 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      record: {
-        $type: 'app.bsky.feed.repost',
-        subject: { uri: uriA.toString(), cid: cidA.toString() },
-        createdAt: now,
-      },
-    })
-    const { data: repost2 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      record: {
-        $type: 'app.bsky.feed.repost',
-        subject: { uri: uriB.toString(), cid: cidB.toString() },
-        createdAt: now,
-      },
-    })
-    const { data: repost3 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      record: {
-        $type: 'app.bsky.feed.repost',
-        subject: { uri: uriA.toString(), cid: cidA.toString() },
-        createdAt: now,
-      },
-    })
-
-    const getRepost1 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      rkey: new AtUri(repost1.uri).rkey,
-    })
-
-    await expect(getRepost1).rejects.toThrow('Could not locate record:')
-
-    const getRepost2 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      rkey: new AtUri(repost2.uri).rkey,
-    })
-
-    await expect(getRepost2).resolves.toBeDefined()
-
-    const getRepost3 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.feed.repost',
-      rkey: new AtUri(repost3.uri).rkey,
-    })
-
-    await expect(getRepost3).resolves.toBeDefined()
-  })
-
-  it('prevents duplicate blocks', async () => {
-    const now = new Date().toISOString()
-
-    const { data: block1 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      record: {
-        $type: 'app.bsky.graph.block',
-        subject: bobAgent.assertDid,
-        createdAt: now,
-      },
-    })
-
-    const { data: block2 } = await bobAgent.com.atproto.repo.createRecord({
-      repo: bobAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      record: {
-        $type: 'app.bsky.graph.block',
-        subject: aliceAgent.assertDid,
-        createdAt: now,
-      },
-    })
-
-    const { data: block3 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      record: {
-        $type: 'app.bsky.graph.block',
-        subject: bobAgent.assertDid,
-        createdAt: now,
-      },
-    })
-
-    const getBlock1 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      rkey: new AtUri(block1.uri).rkey,
-    })
-
-    await expect(getBlock1).rejects.toThrow('Could not locate record:')
-
-    const getBlock2 = aliceAgent.com.atproto.repo.getRecord({
-      repo: bobAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      rkey: new AtUri(block2.uri).rkey,
-    })
-
-    await expect(getBlock2).resolves.toBeDefined()
-
-    const getBlock3 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.block',
-      rkey: new AtUri(block3.uri).rkey,
-    })
-
-    await expect(getBlock3).resolves.toBeDefined()
-  })
-
-  it('prevents duplicate follows', async () => {
-    const now = new Date().toISOString()
-
-    const { data: follow1 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      record: {
-        $type: 'app.bsky.graph.follow',
-        subject: bobAgent.assertDid,
-        createdAt: now,
-      },
-    })
-    const { data: follow2 } = await bobAgent.com.atproto.repo.createRecord({
-      repo: bobAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      record: {
-        $type: 'app.bsky.graph.follow',
-        subject: aliceAgent.assertDid,
-        createdAt: now,
-      },
-    })
-    const { data: follow3 } = await aliceAgent.com.atproto.repo.createRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      record: {
-        $type: 'app.bsky.graph.follow',
-        subject: bobAgent.assertDid,
-        createdAt: now,
-      },
-    })
-
-    const getFollow1 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      rkey: new AtUri(follow1.uri).rkey,
-    })
-
-    await expect(getFollow1).rejects.toThrow('Could not locate record:')
-
-    const getFollow2 = aliceAgent.com.atproto.repo.getRecord({
-      repo: bobAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      rkey: new AtUri(follow2.uri).rkey,
-    })
-
-    await expect(getFollow2).resolves.toBeDefined()
-
-    const getFollow3 = aliceAgent.com.atproto.repo.getRecord({
-      repo: aliceAgent.assertDid,
-      collection: 'app.bsky.graph.follow',
-      rkey: new AtUri(follow3.uri).rkey,
-    })
-
-    await expect(getFollow3).resolves.toBeDefined()
-  })
-
-  // Moderation
-  // --------------
-
-  it("doesn't serve taken-down record", async () => {
-    const created = await aliceAgent.app.bsky.feed.post.create(
-      { repo: aliceAgent.assertDid },
-      {
-        $type: 'app.bsky.feed.post',
-        text: 'Hello, world!',
-        createdAt: new Date().toISOString(),
-      },
-    )
-    const postUri = new AtUri(created.uri)
-    const post = await agent.app.bsky.feed.post.get({
-      repo: aliceAgent.assertDid,
-      rkey: postUri.rkey,
-    })
-    const posts = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(posts.records.map((r) => r.uri)).toContain(post.uri)
-
-    const subject = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: created.uri,
-      cid: created.cid,
-    }
-    await agent.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: true },
-      },
-      {
-        encoding: 'application/json',
-        headers: { authorization: network.pds.adminAuth() },
-      },
-    )
-
-    const postTakedownPromise = agent.app.bsky.feed.post.get({
-      repo: aliceAgent.assertDid,
-      rkey: postUri.rkey,
-    })
-    await expect(postTakedownPromise).rejects.toThrow('Could not locate record')
-    const postsTakedown = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(postsTakedown.records.map((r) => r.uri)).not.toContain(post.uri)
-
-    // Cleanup
-    await agent.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: { authorization: network.pds.adminAuth() },
-      },
-    )
-  })
-
-  it("doesn't serve taken-down actor", async () => {
-    const posts = await agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    expect(posts.records.length).toBeGreaterThan(0)
-
-    const subject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: aliceAgent.assertDid,
-    }
-
-    await agent.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: true },
-      },
-      {
-        encoding: 'application/json',
-        headers: { authorization: network.pds.adminAuth() },
-      },
-    )
-
-    const tryListPosts = agent.app.bsky.feed.post.list({
-      repo: aliceAgent.assertDid,
-    })
-    await expect(tryListPosts).rejects.toThrow(/Could not find repo/)
-
-    // Cleanup
-    await agent.com.atproto.admin.updateSubjectStatus(
-      {
-        subject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: { authorization: network.pds.adminAuth() },
-      },
-    )
-  })
-})
-
-function createDeepObject(depth: number) {
-  const obj: any = {}
-  let iter = obj
-  for (let i = 0; i < depth; ++i) {
-    iter.x = {}
-    iter = iter.x
-  }
-  return obj
-}