@atproto/bsky 0.0.15 → 0.0.17

package/tests/admin/repo-search.test.ts

@@ -1,6 +1,5 @@
 import { SeedClient, TestNetwork } from '@atproto/dev-env'
 import AtpAgent from '@atproto/api'
-import { TAKEDOWN } from '@atproto/api/src/client/types/com/atproto/admin/defs'
 import { paginateAll } from '../_util'
 import usersBulkSeed from '../seeds/users-bulk'
 
@@ -18,6 +17,7 @@ describe('admin repo search view', () => {
     sc = network.getSeedClient()
     await usersBulkSeed(sc)
     headers = network.pds.adminAuthHeaders()
+    await network.processAll()
   })
 
   afterAll(async () => {
@@ -25,8 +25,8 @@ describe('admin repo search view', () => {
   })
 
   beforeAll(async () => {
-    await sc.takeModerationAction({
-      action: TAKEDOWN,
+    await sc.emitModerationEvent({
+      event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
       subject: {
         $type: 'com.atproto.admin.defs#repoRef',
         did: sc.dids['cara-wiegand69.test'],

package/tests/algos/hot-classic.test.ts

@@ -31,7 +31,6 @@ describe('algo hot-classic', () => {
     alice = sc.dids.alice
     bob = sc.dids.bob
     await network.processAll()
-    await network.bsky.processAll()
   })
 
   afterAll(async () => {
@@ -59,7 +58,7 @@ describe('algo hot-classic', () => {
       await sc.like(sc.dids[name], two.ref)
       await sc.like(sc.dids[name], three.ref)
     }
-    await network.bsky.processAll()
+    await network.processAll()
 
     const res = await agent.api.app.bsky.feed.getFeed(
       { feed: feedUri },

package/tests/auth.test.ts

@@ -36,7 +36,7 @@ describe('auth', () => {
         { headers: { authorization: `Bearer ${jwt}` } },
       )
     }
-    const origSigningKey = network.pds.ctx.repoSigningKey
+    const origSigningKey = await network.pds.ctx.actorStore.keypair(issuer)
     const newSigningKey = await Secp256k1Keypair.create({ exportable: true })
     // confirm original signing key works
     await expect(attemptWithKey(origSigningKey)).resolves.toBeDefined()

package/tests/auto-moderator/fuzzy-matcher.test.ts

@@ -37,7 +37,8 @@ describe('fuzzy matcher', () => {
   const getAllReports = () => {
     return network.bsky.ctx.db
       .getPrimary()
-      .db.selectFrom('moderation_report')
+      .db.selectFrom('moderation_event')
+      .where('action', '=', 'com.atproto.admin.defs#modEventReport')
       .selectAll()
       .orderBy('id', 'asc')
       .execute()

package/tests/auto-moderator/labeler.test.ts

@@ -40,26 +40,25 @@ describe('labeler', () => {
     await usersSeed(sc)
     await network.processAll()
     alice = sc.dids.alice
-    const repoSvc = pdsCtx.services.repo(pdsCtx.db)
-    const storeBlob = async (bytes: Uint8Array) => {
-      const blobRef = await repoSvc.blobs.addUntetheredBlob(
-        alice,
-        'image/jpeg',
-        Readable.from([bytes], { objectMode: false }),
-      )
-      const preparedBlobRef = {
-        cid: blobRef.ref,
-        mimeType: 'image/jpeg',
-        constraints: {},
-      }
-      await repoSvc.blobs.verifyBlobAndMakePermanent(alice, preparedBlobRef)
-      await repoSvc.blobs.associateBlob(
-        preparedBlobRef,
-        postUri(),
-        TID.nextStr(),
-        alice,
-      )
-      return blobRef
+    const storeBlob = (bytes: Uint8Array) => {
+      return pdsCtx.actorStore.transact(alice, async (store) => {
+        const blobRef = await store.repo.blob.addUntetheredBlob(
+          'image/jpeg',
+          Readable.from([bytes], { objectMode: false }),
+        )
+        const preparedBlobRef = {
+          cid: blobRef.ref,
+          mimeType: 'image/jpeg',
+          constraints: {},
+        }
+        await store.repo.blob.verifyBlobAndMakePermanent(preparedBlobRef)
+        await store.repo.blob.associateBlob(
+          preparedBlobRef,
+          postUri(),
+          TID.nextStr(),
+        )
+        return blobRef
+      })
     }
     const bytes1 = new Uint8Array([1, 2, 3, 4])
     const bytes2 = new Uint8Array([5, 6, 7, 8])

package/tests/auto-moderator/takedowns.test.ts

@@ -77,28 +77,45 @@ describe('takedowner', () => {
     const post = await sc.post(alice, 'blah', undefined, [goodBlob, badBlob1])
     await network.processAll()
     await autoMod.processAll()
-    const modAction = await ctx.db.db
-      .selectFrom('moderation_action')
-      .where('subjectUri', '=', post.ref.uriStr)
-      .select(['action', 'id'])
-      .executeTakeFirst()
-    if (!modAction) {
+    const [modStatus, takedownEvent] = await Promise.all([
+      ctx.db.db
+        .selectFrom('moderation_subject_status')
+        .where('did', '=', alice)
+        .where(
+          'recordPath',
+          '=',
+          `${post.ref.uri.collection}/${post.ref.uri.rkey}`,
+        )
+        .select(['takendown', 'id'])
+        .executeTakeFirst(),
+      ctx.db.db
+        .selectFrom('moderation_event')
+        .where('subjectDid', '=', alice)
+        .where('action', '=', 'com.atproto.admin.defs#modEventTakedown')
+        .selectAll()
+        .executeTakeFirst(),
+    ])
+    if (!modStatus || !takedownEvent) {
       throw new Error('expected mod action')
     }
-    expect(modAction.action).toEqual('com.atproto.admin.defs#takedown')
+    expect(modStatus.takendown).toEqual(true)
     const record = await ctx.db.db
       .selectFrom('record')
       .where('uri', '=', post.ref.uriStr)
       .select('takedownId')
       .executeTakeFirst()
-    expect(record?.takedownId).toEqual(modAction.id)
+    expect(record?.takedownId).toBeGreaterThan(0)
 
-    const recordPds = await network.pds.ctx.db.db
-      .selectFrom('record')
-      .where('uri', '=', post.ref.uriStr)
-      .select('takedownRef')
-      .executeTakeFirst()
-    expect(recordPds?.takedownRef).toEqual(modAction.id.toString())
+    const recordPds = await network.pds.ctx.actorStore.read(
+      post.ref.uri.hostname,
+      (store) =>
+        store.db.db
+          .selectFrom('record')
+          .where('uri', '=', post.ref.uriStr)
+          .select('takedownRef')
+          .executeTakeFirst(),
+    )
+    expect(recordPds?.takedownRef).toEqual(takedownEvent.id.toString())
 
     expect(testInvalidator.invalidated.length).toBe(1)
     expect(testInvalidator.invalidated[0].subject).toBe(
@@ -119,28 +136,44 @@ describe('takedowner', () => {
       { headers: sc.getHeaders(alice), encoding: 'application/json' },
     )
     await network.processAll()
-    const modAction = await ctx.db.db
-      .selectFrom('moderation_action')
-      .where('subjectUri', '=', res.data.uri)
-      .select(['action', 'id'])
-      .executeTakeFirst()
-    if (!modAction) {
+    const [modStatus, takedownEvent] = await Promise.all([
+      ctx.db.db
+        .selectFrom('moderation_subject_status')
+        .where('did', '=', alice)
+        .where('recordPath', '=', `${ids.AppBskyActorProfile}/self`)
+        .select(['takendown', 'id'])
+        .executeTakeFirst(),
+      ctx.db.db
+        .selectFrom('moderation_event')
+        .where('subjectDid', '=', alice)
+        .where(
+          'subjectUri',
+          '=',
+          AtUri.make(alice, ids.AppBskyActorProfile, 'self').toString(),
+        )
+        .where('action', '=', 'com.atproto.admin.defs#modEventTakedown')
+        .selectAll()
+        .executeTakeFirst(),
+    ])
+    if (!modStatus || !takedownEvent) {
       throw new Error('expected mod action')
     }
-    expect(modAction.action).toEqual('com.atproto.admin.defs#takedown')
+    expect(modStatus.takendown).toEqual(true)
     const record = await ctx.db.db
       .selectFrom('record')
       .where('uri', '=', res.data.uri)
       .select('takedownId')
       .executeTakeFirst()
-    expect(record?.takedownId).toEqual(modAction.id)
+    expect(record?.takedownId).toBeGreaterThan(0)
 
-    const recordPds = await network.pds.ctx.db.db
-      .selectFrom('record')
-      .where('uri', '=', res.data.uri)
-      .select('takedownRef')
-      .executeTakeFirst()
-    expect(recordPds?.takedownRef).toEqual(modAction.id.toString())
+    const recordPds = await network.pds.ctx.actorStore.read(alice, (store) =>
+      store.db.db
+        .selectFrom('record')
+        .where('uri', '=', res.data.uri)
+        .select('takedownRef')
+        .executeTakeFirst(),
+    )
+    expect(recordPds?.takedownRef).toEqual(takedownEvent.id.toString())
 
     expect(testInvalidator.invalidated.length).toBe(2)
     expect(testInvalidator.invalidated[1].subject).toBe(

package/tests/blob-resolver.test.ts

@@ -77,8 +77,10 @@ describe('blob resolver', () => {
   })
 
   it('fails on blob with bad signature check.', async () => {
-    await network.pds.ctx.blobstore.delete(fileCid)
-    await network.pds.ctx.blobstore.putPermanent(fileCid, randomBytes(100))
+    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',

package/tests/daemon.test.ts

@@ -0,0 +1,191 @@
+import assert from 'assert'
+import { AtUri } from '@atproto/api'
+import { TestNetwork } from '@atproto/dev-env'
+import { BskyDaemon, DaemonConfig, PrimaryDatabase } from '../src'
+import usersSeed from './seeds/users'
+import { countAll, excluded } from '../src/db/util'
+import { NotificationsDaemon } from '../src/daemon/notifications'
+import {
+  BEFORE_LAST_SEEN_DAYS,
+  BEFORE_LATEST_UNREAD_DAYS,
+  UNREAD_KEPT_COUNT,
+} from '../src/services/util/notification'
+
+describe('daemon', () => {
+  let network: TestNetwork
+  let daemon: BskyDaemon
+  let db: PrimaryDatabase
+  let actors: { did: string }[] = []
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_daemon',
+    })
+    db = network.bsky.ctx.db.getPrimary()
+    daemon = BskyDaemon.create({
+      db,
+      cfg: new DaemonConfig({
+        version: network.bsky.ctx.cfg.version,
+        dbPostgresUrl: network.bsky.ctx.cfg.dbPrimaryPostgresUrl,
+        dbPostgresSchema: network.bsky.ctx.cfg.dbPostgresSchema,
+      }),
+    })
+    const sc = network.getSeedClient()
+    await usersSeed(sc)
+    await network.processAll()
+    actors = await db.db.selectFrom('actor').selectAll().execute()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('notifications daemon', () => {
+    it('processes all dids', async () => {
+      for (const { did } of actors) {
+        await Promise.all([
+          setLastSeen(daemon.ctx.db, { did }),
+          createNotifications(daemon.ctx.db, {
+            did,
+            daysAgo: 2 * BEFORE_LAST_SEEN_DAYS,
+            count: 1,
+          }),
+        ])
+      }
+      await expect(countNotifications(db)).resolves.toBe(actors.length)
+      await runNotifsOnce(daemon.notifications)
+      await expect(countNotifications(db)).resolves.toBe(0)
+    })
+
+    it('removes read notifications older than threshold.', async () => {
+      const { did } = actors[0]
+      const lastSeenDaysAgo = 10
+      await Promise.all([
+        setLastSeen(daemon.ctx.db, { did, daysAgo: lastSeenDaysAgo }),
+        // read, delete
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: lastSeenDaysAgo + BEFORE_LAST_SEEN_DAYS + 1,
+          count: 2,
+        }),
+        // read, keep
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: lastSeenDaysAgo + BEFORE_LAST_SEEN_DAYS - 1,
+          count: 3,
+        }),
+        // unread, keep
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: lastSeenDaysAgo - 1,
+          count: 4,
+        }),
+      ])
+      await expect(countNotifications(db)).resolves.toBe(9)
+      await runNotifsOnce(daemon.notifications)
+      await expect(countNotifications(db)).resolves.toBe(7)
+      await clearNotifications(db)
+    })
+
+    it('removes unread notifications older than threshold.', async () => {
+      const { did } = actors[0]
+      await Promise.all([
+        setLastSeen(daemon.ctx.db, {
+          did,
+          daysAgo: 2 * BEFORE_LATEST_UNREAD_DAYS, // all are unread
+        }),
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: 0,
+          count: 1,
+        }),
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: BEFORE_LATEST_UNREAD_DAYS - 1,
+          count: 99,
+        }),
+        createNotifications(daemon.ctx.db, {
+          did,
+          daysAgo: BEFORE_LATEST_UNREAD_DAYS + 1,
+          count: 400,
+        }),
+      ])
+      await expect(countNotifications(db)).resolves.toBe(UNREAD_KEPT_COUNT)
+      await runNotifsOnce(daemon.notifications)
+      // none removed when within UNREAD_KEPT_COUNT
+      await expect(countNotifications(db)).resolves.toBe(UNREAD_KEPT_COUNT)
+      // add one more, tip over UNREAD_KEPT_COUNT
+      await createNotifications(daemon.ctx.db, {
+        did,
+        daysAgo: BEFORE_LATEST_UNREAD_DAYS + 1,
+        count: 1,
+      })
+      await runNotifsOnce(daemon.notifications)
+      // removed all older than BEFORE_LATEST_UNREAD_DAYS
+      await expect(countNotifications(db)).resolves.toBe(100)
+      await clearNotifications(db)
+    })
+  })
+
+  const runNotifsOnce = async (notifsDaemon: NotificationsDaemon) => {
+    assert(!notifsDaemon.running, 'notifications daemon is already running')
+    notifsDaemon.run({ forever: false, batchSize: 2 })
+    await notifsDaemon.running
+  }
+
+  const setLastSeen = async (
+    db: PrimaryDatabase,
+    opts: { did: string; daysAgo?: number },
+  ) => {
+    const { did, daysAgo = 0 } = opts
+    const lastSeenAt = new Date()
+    lastSeenAt.setDate(lastSeenAt.getDate() - daysAgo)
+    await db.db
+      .insertInto('actor_state')
+      .values({ did, lastSeenNotifs: lastSeenAt.toISOString() })
+      .onConflict((oc) =>
+        oc.column('did').doUpdateSet({
+          lastSeenNotifs: excluded(db.db, 'lastSeenNotifs'),
+        }),
+      )
+      .execute()
+  }
+
+  const createNotifications = async (
+    db: PrimaryDatabase,
+    opts: {
+      did: string
+      count: number
+      daysAgo: number
+    },
+  ) => {
+    const { did, count, daysAgo } = opts
+    const sortAt = new Date()
+    sortAt.setDate(sortAt.getDate() - daysAgo)
+    await db.db
+      .insertInto('notification')
+      .values(
+        [...Array(count)].map(() => ({
+          did,
+          author: did,
+          reason: 'none',
+          recordCid: 'bafycid',
+          recordUri: AtUri.make(did, 'invalid.collection', 'self').toString(),
+          sortAt: sortAt.toISOString(),
+        })),
+      )
+      .execute()
+  }
+
+  const clearNotifications = async (db: PrimaryDatabase) => {
+    await db.db.deleteFrom('notification').execute()
+  }
+
+  const countNotifications = async (db: PrimaryDatabase) => {
+    const { count } = await db.db
+      .selectFrom('notification')
+      .select(countAll.as('count'))
+      .executeTakeFirstOrThrow()
+    return count
+  }
+})

package/tests/did-cache.test.ts

@@ -1,14 +1,16 @@
 import { TestNetwork, SeedClient } from '@atproto/dev-env'
 import userSeed from './seeds/users'
 import { IdResolver } from '@atproto/identity'
-import DidSqlCache from '../src/did-cache'
+import DidRedisCache from '../src/did-cache'
 import { wait } from '@atproto/common'
+import { Redis } from '../src'
 
 describe('did cache', () => {
   let network: TestNetwork
   let sc: SeedClient
   let idResolver: IdResolver
-  let didCache: DidSqlCache
+  let redis: Redis
+  let didCache: DidRedisCache
 
   let alice: string
   let bob: string
@@ -20,6 +22,7 @@ describe('did cache', () => {
       dbPostgresSchema: 'bsky_did_cache',
     })
     idResolver = network.bsky.indexer.ctx.idResolver
+    redis = network.bsky.indexer.ctx.redis
     didCache = network.bsky.indexer.ctx.didCache
     sc = network.getSeedClient()
     await userSeed(sc)
@@ -50,7 +53,12 @@ describe('did cache', () => {
   })
 
   it('clears cache and repopulates', async () => {
-    await idResolver.did.cache?.clear()
+    await Promise.all([
+      idResolver.did.cache?.clearEntry(alice),
+      idResolver.did.cache?.clearEntry(bob),
+      idResolver.did.cache?.clearEntry(carol),
+      idResolver.did.cache?.clearEntry(dan),
+    ])
     const docsCleared = await Promise.all([
       idResolver.did.cache?.checkCache(alice),
       idResolver.did.cache?.checkCache(bob),
@@ -81,7 +89,10 @@ describe('did cache', () => {
   })
 
   it('accurately reports expired dids & refreshes the cache', async () => {
-    const didCache = new DidSqlCache(network.bsky.ctx.db.getPrimary(), 1, 60000)
+    const didCache = new DidRedisCache(redis.withNamespace('did-doc'), {
+      staleTTL: 1,
+      maxTTL: 60000,
+    })
     const shortCacheResolver = new IdResolver({
       plcUrl: network.bsky.ctx.cfg.didPlcUrl,
       didCache,
@@ -110,7 +121,10 @@ describe('did cache', () => {
   })
 
   it('does not return expired dids & refreshes the cache', async () => {
-    const didCache = new DidSqlCache(network.bsky.ctx.db.getPrimary(), 0, 1)
+    const didCache = new DidRedisCache(redis.withNamespace('did-doc'), {
+      staleTTL: 0,
+      maxTTL: 1,
+    })
     const shortExpireResolver = new IdResolver({
       plcUrl: network.bsky.ctx.cfg.didPlcUrl,
       didCache,
@@ -125,5 +139,6 @@ describe('did cache', () => {
     // see that the resolver does not return expired value & instead force refreshes
     const staleGet = await shortExpireResolver.did.resolve(alice)
     expect(staleGet?.id).toEqual(alice)
+    await didCache.destroy()
   })
 })

package/tests/feed-generation.test.ts

@@ -9,7 +9,6 @@ import {
 import { Handler as SkeletonHandler } from '../src/lexicon/types/app/bsky/feed/getFeedSkeleton'
 import { GeneratorView } from '@atproto/api/src/client/types/app/bsky/feed/defs'
 import { UnknownFeedError } from '@atproto/api/src/client/types/app/bsky/feed/getFeed'
-import { TAKEDOWN } from '@atproto/api/src/client/types/com/atproto/admin/defs'
 import { ids } from '../src/lexicon/lexicons'
 import {
   FeedViewPost,
@@ -17,6 +16,9 @@ import {
 } from '../src/lexicon/types/app/bsky/feed/defs'
 import basicSeed from './seeds/basic'
 import { forSnapshot, paginateAll } from './_util'
+import { AuthRequiredError } from '@atproto/xrpc-server'
+import assert from 'assert'
+import { XRPCError } from '@atproto/xrpc'
 
 describe('feed generation', () => {
   let network: TestNetwork
@@ -33,6 +35,7 @@ describe('feed generation', () => {
   let feedUriBadPagination: string
   let feedUriPrime: string // Taken-down
   let feedUriPrimeRef: RecordRef
+  let feedUriNeedsAuth: string
 
   beforeAll(async () => {
     network = await TestNetwork.create({
@@ -52,11 +55,17 @@ describe('feed generation', () => {
     )
     const evenUri = AtUri.make(alice, 'app.bsky.feed.generator', 'even')
     const primeUri = AtUri.make(alice, 'app.bsky.feed.generator', 'prime')
+    const needsAuthUri = AtUri.make(
+      alice,
+      'app.bsky.feed.generator',
+      'needs-auth',
+    )
     gen = await network.createFeedGen({
       [allUri.toString()]: feedGenHandler('all'),
       [evenUri.toString()]: feedGenHandler('even'),
       [feedUriBadPagination.toString()]: feedGenHandler('bad-pagination'),
       [primeUri.toString()]: feedGenHandler('prime'),
+      [needsAuthUri.toString()]: feedGenHandler('needs-auth'),
     })
 
     const feedSuggestions = [
@@ -137,10 +146,20 @@ describe('feed generation', () => {
       },
       sc.getHeaders(alice),
     )
+    const needsAuth = await pdsAgent.api.app.bsky.feed.generator.create(
+      { repo: alice, rkey: 'needs-auth' },
+      {
+        did: gen.did,
+        displayName: 'Needs Auth',
+        description: 'Provides all feed candidates when authed',
+        createdAt: new Date().toISOString(),
+      },
+      sc.getHeaders(alice),
+    )
     await network.processAll()
-    await agent.api.com.atproto.admin.takeModerationAction(
+    await agent.api.com.atproto.admin.emitModerationEvent(
       {
-        action: TAKEDOWN,
+        event: { $type: 'com.atproto.admin.defs#modEventTakedown' },
         subject: {
           $type: 'com.atproto.repo.strongRef',
           uri: prime.uri,
@@ -161,6 +180,7 @@ describe('feed generation', () => {
     feedUriBadPagination = badPagination.uri
     feedUriPrime = prime.uri
     feedUriPrimeRef = new RecordRef(prime.uri, prime.cid)
+    feedUriNeedsAuth = needsAuth.uri
   })
 
   it('feed gen records can be updated', async () => {
@@ -198,11 +218,12 @@ describe('feed generation', () => {
 
     const paginatedAll: GeneratorView[] = results(await paginateAll(paginator))
 
-    expect(paginatedAll.length).toEqual(4)
+    expect(paginatedAll.length).toEqual(5)
     expect(paginatedAll[0].uri).toEqual(feedUriOdd)
-    expect(paginatedAll[1].uri).toEqual(feedUriBadPagination)
-    expect(paginatedAll[2].uri).toEqual(feedUriEven)
-    expect(paginatedAll[3].uri).toEqual(feedUriAll)
+    expect(paginatedAll[1].uri).toEqual(feedUriNeedsAuth)
+    expect(paginatedAll[2].uri).toEqual(feedUriBadPagination)
+    expect(paginatedAll[3].uri).toEqual(feedUriEven)
+    expect(paginatedAll[4].uri).toEqual(feedUriAll)
     expect(paginatedAll.map((fg) => fg.uri)).not.toContain(feedUriPrime) // taken-down
     expect(forSnapshot(paginatedAll)).toMatchSnapshot()
   })
@@ -348,7 +369,9 @@ describe('feed generation', () => {
           {},
           { headers: await network.serviceHeaders(sc.dids.bob) },
         )
-      expect(resEven.data.feeds.map((f) => f.likeCount)).toEqual([2, 0, 0, 0])
+      expect(resEven.data.feeds.map((f) => f.likeCount)).toEqual([
+        2, 0, 0, 0, 0,
+      ])
       expect(resEven.data.feeds.map((f) => f.uri)).not.toContain(feedUriPrime) // taken-down
     })
 
@@ -389,6 +412,16 @@ describe('feed generation', () => {
       expect(forSnapshot(feed.data.feed)).toMatchSnapshot()
     })
 
+    it('resolves basic feed contents without auth.', async () => {
+      const feed = await agent.api.app.bsky.feed.getFeed({ feed: feedUriEven })
+      expect(feed.data.feed.map((item) => item.post.uri)).toEqual([
+        sc.posts[sc.dids.alice][0].ref.uriStr,
+        sc.posts[sc.dids.carol][0].ref.uriStr,
+        sc.replies[sc.dids.carol][0].ref.uriStr,
+      ])
+      expect(forSnapshot(feed.data.feed)).toMatchSnapshot()
+    })
+
     it('paginates, handling replies and reposts.', async () => {
       const results = (results) => results.flatMap((res) => res.feed)
       const paginator = async (cursor?: string) => {
@@ -461,6 +494,16 @@ describe('feed generation', () => {
       expect(feed.data['$auth']?.['iss']).toEqual(alice)
     })
 
+    it('passes through auth error from feed.', async () => {
+      const tryGetFeed = agent.api.app.bsky.feed.getFeed({
+        feed: feedUriNeedsAuth,
+      })
+      const err = await tryGetFeed.catch((err) => err)
+      assert(err instanceof XRPCError)
+      expect(err.status).toBe(401)
+      expect(err.message).toBe('This feed requires auth')
+    })
+
     it('provides timing info in server-timing header.', async () => {
       const result = await agent.api.app.bsky.feed.getFeed(
         { feed: feedUriEven },
@@ -482,8 +525,13 @@ describe('feed generation', () => {
   })
 
   const feedGenHandler =
-    (feedName: 'even' | 'all' | 'prime' | 'bad-pagination'): SkeletonHandler =>
+    (
+      feedName: 'even' | 'all' | 'prime' | 'bad-pagination' | 'needs-auth',
+    ): SkeletonHandler =>
     async ({ req, params }) => {
+      if (feedName === 'needs-auth' && !req.headers.authorization) {
+        throw new AuthRequiredError('This feed requires auth')
+      }
       const { limit, cursor } = params
       const candidates: SkeletonFeedPost[] = [
         { post: sc.posts[sc.dids.alice][0].ref.uriStr },

package/tests/handle-invalidation.test.ts

@@ -102,11 +102,7 @@ describe('handle invalidation', () => {
   it('deals with handle contention', async () => {
     await backdateIndexedAt(bob)
     // update alices handle so that the pds will let bob take her old handle
-    await network.pds.ctx.db.db
-      .updateTable('did_handle')
-      .where('did', '=', alice)
-      .set({ handle: 'not-alice.test' })
-      .execute()
+    await network.pds.ctx.accountManager.updateHandle(alice, 'not-alice.test')
 
     await pdsAgent.api.com.atproto.identity.updateHandle(
       {