@atproto/pds 0.4.28 → 0.4.30

package/tests/account-deactivation.test.ts

@@ -1,5 +1,10 @@
 import AtpAgent from '@atproto/api'
-import { SeedClient, TestNetworkNoAppView, basicSeed } from '@atproto/dev-env'
+import {
+  ImageRef,
+  SeedClient,
+  TestNetworkNoAppView,
+  basicSeed,
+} from '@atproto/dev-env'
 
 describe('account deactivation', () => {
   let network: TestNetworkNoAppView
@@ -8,6 +13,7 @@ describe('account deactivation', () => {
   let agent: AtpAgent
 
   let alice: string
+  let aliceAvatar: ImageRef
 
   beforeAll(async () => {
     network = await TestNetworkNoAppView.create({
@@ -19,6 +25,16 @@ describe('account deactivation', () => {
 
     await basicSeed(sc)
     alice = sc.dids.alice
+
+    aliceAvatar = await sc.uploadFile(
+      alice,
+      '../dev-env/src/seed/img/key-portrait-small.jpg',
+      'image/jpeg',
+    )
+    await sc.updateProfile(alice, {
+      avatar: aliceAvatar.image,
+    })
+
     await network.processAll()
   })
 
@@ -33,16 +49,33 @@ describe('account deactivation', () => {
     )
   })
 
+  it('returns deactivated status', async () => {
+    const res = await agent.com.atproto.sync.getRepoStatus({ did: alice })
+    expect(res.data).toEqual({
+      did: alice,
+      active: false,
+      status: 'deactivated',
+    })
+
+    const adminRes = await agent.com.atproto.admin.getAccountInfo(
+      {
+        did: alice,
+      },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    expect(typeof adminRes.data.deactivatedAt).toBeDefined()
+  })
+
   it('no longer serves repo data', async () => {
     await expect(
       agent.com.atproto.sync.getRepo({ did: alice }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
     await expect(
       agent.com.atproto.sync.getLatestCommit({ did: alice }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
     await expect(
       agent.com.atproto.sync.listBlobs({ did: alice }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
     const recordUri = sc.posts[alice][0].ref.uri
     await expect(
       agent.com.atproto.sync.getRecord({
@@ -50,7 +83,7 @@ describe('account deactivation', () => {
         collection: recordUri.collection,
         rkey: recordUri.rkey,
       }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
     await expect(
       agent.com.atproto.repo.getRecord({
         repo: alice,
@@ -62,17 +95,18 @@ describe('account deactivation', () => {
       agent.com.atproto.repo.describeRepo({
         repo: alice,
       }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
 
-    const blobCid = sc.profiles[alice].avatar.cid
     await expect(
       agent.com.atproto.sync.getBlob({
         did: alice,
-        cid: blobCid,
+        cid: aliceAvatar.image.ref.toString(),
       }),
-    ).rejects.toThrow()
+    ).rejects.toThrow(/Repo has been deactivated/)
     const listedRepos = await agent.com.atproto.sync.listRepos()
-    expect(listedRepos.data.repos.find((r) => r.did === alice)).toBeUndefined()
+    const listedAlice = listedRepos.data.repos.find((r) => r.did === alice)
+    expect(listedAlice?.active).toBe(false)
+    expect(listedAlice?.status).toBe('deactivated')
   })
 
   it('no longer resolves handle', async () => {
@@ -83,11 +117,19 @@ describe('account deactivation', () => {
     ).rejects.toThrow()
   })
 
-  it('still allows login', async () => {
-    await agent.com.atproto.server.createSession({
+  it('still allows login and returns status', async () => {
+    const res = await agent.com.atproto.server.createSession({
       identifier: alice,
       password: sc.accounts[alice].password,
     })
+    expect(res.data.status).toEqual('deactivated')
+  })
+
+  it('returns status on getSession', async () => {
+    const res = await agent.com.atproto.server.getSession(undefined, {
+      headers: sc.getHeaders(alice),
+    })
+    expect(res.data.status).toEqual('deactivated')
   })
 
   it('does not allow writes', async () => {
@@ -143,6 +185,19 @@ describe('account deactivation', () => {
     await agent.com.atproto.server.activateAccount(undefined, {
       headers: sc.getHeaders(alice),
     })
+
     await agent.com.atproto.sync.getRepo({ did: alice })
+
+    const statusRes = await agent.com.atproto.sync.getRepoStatus({ did: alice })
+    expect(statusRes.data.active).toBe(true)
+    expect(statusRes.data.status).toBeUndefined()
+
+    const adminRes = await agent.com.atproto.admin.getAccountInfo(
+      {
+        did: alice,
+      },
+      { headers: network.pds.adminAuthHeaders() },
+    )
+    expect(adminRes.data.deactivatedAt).toBeUndefined()
   })
 })

package/tests/account-deletion.test.ts

@@ -143,10 +143,18 @@ describe('account deletion', () => {
     expect(updatedDbContents.userAccounts).toEqual(
       initialDbContents.userAccounts.filter((row) => row.did !== carol.did),
     )
-    // check all seqs for this did are gone, except for the tombstone
+    // check we didn't touch other user seqs
     expect(
-      updatedDbContents.repoSeqs.filter((row) => row.eventType !== 'tombstone'),
+      updatedDbContents.repoSeqs.filter((row) => row.did !== carol.did),
     ).toEqual(initialDbContents.repoSeqs.filter((row) => row.did !== carol.did))
+    // check all seqs for this did are gone, except for the tombstone & account events
+    expect(
+      updatedDbContents.repoSeqs
+        .filter((row) => row.did === carol.did)
+        .every(
+          (row) => row.eventType === 'tombstone' || row.eventType === 'account',
+        ),
+    ).toBe(true)
     // check we do have a tombstone for this did
     expect(
       updatedDbContents.repoSeqs.filter(

package/tests/auth.test.ts

@@ -62,6 +62,7 @@ describe('auth', () => {
       handle: account.handle,
       email,
       emailConfirmed: false,
+      active: true,
     })
     // Valid refresh token
     const nextSession = await refreshSession(account.refreshJwt)
@@ -91,6 +92,7 @@ describe('auth', () => {
       handle: session.handle,
       email,
       emailConfirmed: false,
+      active: true,
     })
     // Valid refresh token
     const nextSession = await refreshSession(session.refreshJwt)
@@ -135,6 +137,7 @@ describe('auth', () => {
       handle: session.handle,
       email,
       emailConfirmed: false,
+      active: true,
     })
     // Valid refresh token
     const nextSession = await refreshSession(session.refreshJwt)

package/tests/moderation.test.ts

@@ -238,12 +238,12 @@ describe('moderation', () => {
       }
       // public, disallow
       const attempt1 = agent.api.com.atproto.sync.getBlob(blobParams)
-      await expect(attempt1).rejects.toThrow('Blob not found')
+      await expect(attempt1).rejects.toThrow(/Repo has been takendown/)
       // logged-in, disallow
       const attempt2 = agent.api.com.atproto.sync.getBlob(blobParams, {
         headers: sc.getHeaders(sc.dids.bob),
       })
-      await expect(attempt2).rejects.toThrow('Blob not found')
+      await expect(attempt2).rejects.toThrow(/Repo has been takendown/)
       // logged-in as account, allow
       const res1 = await agent.api.com.atproto.sync.getBlob(blobParams, {
         headers: sc.getHeaders(sc.dids.carol),

package/tests/proxied/notif.test.ts

@@ -37,6 +37,7 @@ describe('notif service proxy', () => {
       }
       return x
     })
+    await network.pds.ctx.idResolver.did.resolve(notifDid, true)
   })
 
   afterAll(async () => {

package/tests/sequencer.test.ts

@@ -25,8 +25,8 @@ describe('sequencer', () => {
     await userSeed(sc)
     alice = sc.dids.alice
     bob = sc.dids.bob
-    // 10 events in userSeed
-    totalEvts = 10
+    // 14 events in userSeed
+    totalEvts = 14
   })
 
   afterAll(async () => {

package/tests/sync/list.test.ts

@@ -29,6 +29,7 @@ describe('sync listing', () => {
       sc.dids.carol,
       sc.dids.dan,
     ])
+    expect(res.data.repos.every((r) => r.active === true)).toBe(true)
   })
 
   it('paginates listed hosted repos', async () => {

package/tests/sync/subscribe-repos.test.ts

@@ -16,10 +16,13 @@ import {
   Commit as CommitEvt,
   Handle as HandleEvt,
   Tombstone as TombstoneEvt,
+  Account as AccountEvt,
+  Identity as IdentityEvt,
 } from '../../src/lexicon/types/com/atproto/sync/subscribeRepos'
 import { AppContext } from '../../src'
 import basicSeed from '../seeds/basic'
 import { CID } from 'multiformats/cid'
+import { AccountStatus } from '../../src/account-manager'
 
 describe('repo subscribe repos', () => {
   let serverHost: string
@@ -64,16 +67,6 @@ describe('repo subscribe repos', () => {
     return repo.verifyRepo(car.blocks, car.root, did, signingKey.did())
   }
 
-  const getHandleEvts = (frames: Frame[]): HandleEvt[] => {
-    const evts: HandleEvt[] = []
-    for (const frame of frames) {
-      if (frame instanceof MessageFrame && frame.header.t === '#handle') {
-        evts.push(frame.body)
-      }
-    }
-    return evts
-  }
-
   const getAllEvents = (userDid: string, frames: Frame[]) => {
     const types: unknown[] = []
     for (const frame of frames) {
@@ -93,21 +86,65 @@ describe('repo subscribe repos', () => {
     return types
   }
 
-  const getTombstoneEvts = (frames: Frame[]): TombstoneEvt[] => {
-    const evts: TombstoneEvt[] = []
+  const getEventType = <T>(frames: Frame[], type: string): T[] => {
+    const evts: T[] = []
     for (const frame of frames) {
-      if (frame instanceof MessageFrame && frame.header.t === '#tombstone') {
+      if (frame instanceof MessageFrame && frame.header.t === type) {
         evts.push(frame.body)
       }
     }
     return evts
   }
 
-  const verifyHandleEvent = (evt: unknown, did: string, handle: string) => {
-    expect(evt?.['did']).toBe(did)
-    expect(evt?.['handle']).toBe(handle)
-    expect(typeof evt?.['time']).toBe('string')
-    expect(typeof evt?.['seq']).toBe('number')
+  const getAccountEvts = (frames: Frame[]): AccountEvt[] => {
+    return getEventType(frames, '#account')
+  }
+
+  const getIdentityEvts = (frames: Frame[]): IdentityEvt[] => {
+    return getEventType(frames, '#identity')
+  }
+
+  const getHandleEvts = (frames: Frame[]): HandleEvt[] => {
+    return getEventType(frames, '#handle')
+  }
+
+  const getTombstoneEvts = (frames: Frame[]): TombstoneEvt[] => {
+    return getEventType(frames, '#tombstone')
+  }
+
+  const getCommitEvents = (frames: Frame[]): CommitEvt[] => {
+    return getEventType(frames, '#commit')
+  }
+
+  const verifyIdentityEvent = (
+    evt: IdentityEvt,
+    did: string,
+    handle?: string,
+  ) => {
+    expect(typeof evt.seq).toBe('number')
+    expect(evt.did).toBe(did)
+    expect(typeof evt.time).toBe('string')
+    expect(evt.handle).toEqual(handle)
+  }
+
+  const verifyHandleEvent = (evt: HandleEvt, did: string, handle: string) => {
+    expect(typeof evt.seq).toBe('number')
+    expect(evt.did).toBe(did)
+    expect(evt.handle).toBe(handle)
+    expect(typeof evt.time).toBe('string')
+  }
+
+  const verifyAccountEvent = (
+    evt: AccountEvt,
+    did: string,
+    active: boolean,
+    status?: AccountStatus,
+  ) => {
+    expect(typeof evt.seq).toBe('number')
+    expect(evt.did).toBe(did)
+    expect(typeof evt.time).toBe('string')
+    expect(evt.active).toBe(active)
+    expect(evt.status).toBe(status)
   }
 
   const verifyTombstoneEvent = (evt: unknown, did: string) => {
@@ -116,24 +153,14 @@ describe('repo subscribe repos', () => {
     expect(typeof evt?.['seq']).toBe('number')
   }
 
-  const getCommitEvents = (userDid: string, frames: Frame[]) => {
-    const evts: CommitEvt[] = []
-    for (const frame of frames) {
-      if (frame instanceof MessageFrame && frame.header.t === '#commit') {
-        const body = frame.body as CommitEvt
-        if (body.repo === userDid) {
-          evts.push(frame.body)
-        }
-      }
-    }
-    return evts
-  }
-
   const verifyCommitEvents = async (frames: Frame[]) => {
-    await verifyRepo(alice, getCommitEvents(alice, frames))
-    await verifyRepo(bob, getCommitEvents(bob, frames))
-    await verifyRepo(carol, getCommitEvents(carol, frames))
-    await verifyRepo(dan, getCommitEvents(dan, frames))
+    const forUser = (user: string) => (commit: CommitEvt) =>
+      commit.repo === user
+    const commits = getCommitEvents(frames)
+    await verifyRepo(alice, commits.filter(forUser(alice)))
+    await verifyRepo(bob, commits.filter(forUser(bob)))
+    await verifyRepo(carol, commits.filter(forUser(carol)))
+    await verifyRepo(dan, commits.filter(forUser(dan)))
   }
 
   const verifyRepo = async (did: string, evts: CommitEvt[]) => {
@@ -217,6 +244,19 @@ describe('repo subscribe repos', () => {
     ws.terminate()
 
     await verifyCommitEvents(evts)
+
+    const accountEvts = getAccountEvts(evts)
+    expect(accountEvts.length).toBe(4)
+    verifyAccountEvent(accountEvts[0], alice, true)
+    verifyAccountEvent(accountEvts[1], bob, true)
+    verifyAccountEvent(accountEvts[2], carol, true)
+    verifyAccountEvent(accountEvts[3], dan, true)
+    const identityEvts = getIdentityEvts(evts)
+    expect(identityEvts.length).toBe(4)
+    verifyIdentityEvent(identityEvts[0], alice, 'alice.test')
+    verifyIdentityEvent(identityEvts[1], bob, 'bob.test')
+    verifyIdentityEvent(identityEvts[2], carol, 'carol.test')
+    verifyIdentityEvent(identityEvts[3], dan, 'dan.test')
   })
 
   it('syncs new events', async () => {
@@ -303,9 +343,18 @@ describe('repo subscribe repos', () => {
     ws.terminate()
 
     await verifyCommitEvents(evts)
+
     const handleEvts = getHandleEvts(evts.slice(-6))
+    expect(handleEvts.length).toBe(3)
     verifyHandleEvent(handleEvts[0], alice, 'alice2.test')
     verifyHandleEvent(handleEvts[1], bob, 'bob2.test')
+    verifyHandleEvent(handleEvts[2], bob, 'bob2.test')
+
+    const identityEvts = getIdentityEvts(evts.slice(-6))
+    expect(identityEvts.length).toBe(3)
+    verifyIdentityEvent(identityEvts[0], alice, 'alice2.test')
+    verifyIdentityEvent(identityEvts[1], bob, 'bob2.test')
+    verifyIdentityEvent(identityEvts[2], bob, 'bob2.test')
   })
 
   it('resends handle events on idempotent updates', async () => {
@@ -323,6 +372,121 @@ describe('repo subscribe repos', () => {
     verifyHandleEvent(handleEvts[0], bob, 'bob2.test')
   })
 
+  it('syncs account events', async () => {
+    // deactivate then reactivate alice
+    await agent.api.com.atproto.server.deactivateAccount(
+      {},
+      {
+        encoding: 'application/json',
+        headers: sc.getHeaders(alice),
+      },
+    )
+    await agent.api.com.atproto.server.activateAccount(undefined, {
+      headers: sc.getHeaders(alice),
+    })
+
+    // takedown then restore bob
+    await agent.api.com.atproto.admin.updateSubjectStatus(
+      {
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: bob,
+        },
+        takedown: { applied: true },
+      },
+      {
+        encoding: 'application/json',
+        headers: network.pds.adminAuthHeaders(),
+      },
+    )
+    await agent.api.com.atproto.admin.updateSubjectStatus(
+      {
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: bob,
+        },
+        takedown: { applied: false },
+      },
+      {
+        encoding: 'application/json',
+        headers: network.pds.adminAuthHeaders(),
+      },
+    )
+
+    const ws = new WebSocket(
+      `ws://${serverHost}/xrpc/com.atproto.sync.subscribeRepos?cursor=${-1}`,
+    )
+
+    const gen = byFrame(ws)
+    const evts = await readTillCaughtUp(gen)
+    ws.terminate()
+
+    // @NOTE requires a larger slice because of over-emission on activateAccount - see note on route
+    const accountEvts = getAccountEvts(evts.slice(-6))
+    expect(accountEvts.length).toBe(4)
+    verifyAccountEvent(accountEvts[0], alice, false, AccountStatus.Deactivated)
+    verifyAccountEvent(accountEvts[1], alice, true)
+    verifyAccountEvent(accountEvts[2], bob, false, AccountStatus.Takendown)
+    verifyAccountEvent(accountEvts[3], bob, true)
+  })
+
+  it('syncs interleaved account events', async () => {
+    // deactivate -> takedown -> restore -> activate
+    // deactivate then reactivate alice
+    await agent.api.com.atproto.server.deactivateAccount(
+      {},
+      {
+        encoding: 'application/json',
+        headers: sc.getHeaders(alice),
+      },
+    )
+    await agent.api.com.atproto.admin.updateSubjectStatus(
+      {
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: alice,
+        },
+        takedown: { applied: true },
+      },
+      {
+        encoding: 'application/json',
+        headers: network.pds.adminAuthHeaders(),
+      },
+    )
+    await agent.api.com.atproto.admin.updateSubjectStatus(
+      {
+        subject: {
+          $type: 'com.atproto.admin.defs#repoRef',
+          did: alice,
+        },
+        takedown: { applied: false },
+      },
+      {
+        encoding: 'application/json',
+        headers: network.pds.adminAuthHeaders(),
+      },
+    )
+    await agent.api.com.atproto.server.activateAccount(undefined, {
+      headers: sc.getHeaders(alice),
+    })
+
+    const ws = new WebSocket(
+      `ws://${serverHost}/xrpc/com.atproto.sync.subscribeRepos?cursor=${-1}`,
+    )
+
+    const gen = byFrame(ws)
+    const evts = await readTillCaughtUp(gen)
+    ws.terminate()
+
+    // @NOTE requires a larger slice because of over-emission on activateAccount - see note on route
+    const accountEvts = getAccountEvts(evts.slice(-6))
+    expect(accountEvts.length).toBe(4)
+    verifyAccountEvent(accountEvts[0], alice, false, AccountStatus.Deactivated)
+    verifyAccountEvent(accountEvts[1], alice, false, AccountStatus.Takendown)
+    verifyAccountEvent(accountEvts[2], alice, false, AccountStatus.Deactivated)
+    verifyAccountEvent(accountEvts[3], alice, true)
+  })
+
   it('syncs tombstones', async () => {
     const baddie1 = (
       await sc.createAccount('baddie1.test', {
@@ -338,10 +502,24 @@ describe('repo subscribe repos', () => {
         password: 'baddie2-pass',
       })
     ).did
-
-    for (const did of [baddie1, baddie2]) {
-      await ctx.sequencer.sequenceTombstone(did)
-    }
+    const deleteToken = await ctx.accountManager.createEmailToken(
+      baddie1,
+      'delete_account',
+    )
+    await agent.api.com.atproto.server.deleteAccount({
+      did: baddie1,
+      password: 'baddie1-pass',
+      token: deleteToken,
+    })
+    await agent.api.com.atproto.admin.deleteAccount(
+      {
+        did: baddie2,
+      },
+      {
+        encoding: 'application/json',
+        headers: network.pds.adminAuthHeaders(),
+      },
+    )
 
     const ws = new WebSocket(
       `ws://${serverHost}/xrpc/com.atproto.sync.subscribeRepos?cursor=${-1}`,
@@ -351,9 +529,15 @@ describe('repo subscribe repos', () => {
     const evts = await readTillCaughtUp(gen)
     ws.terminate()
 
-    const tombstoneEvts = getTombstoneEvts(evts.slice(-2))
+    const tombstoneEvts = getTombstoneEvts(evts.slice(-4))
+    expect(tombstoneEvts.length).toBe(2)
     verifyTombstoneEvent(tombstoneEvts[0], baddie1)
     verifyTombstoneEvent(tombstoneEvts[1], baddie2)
+
+    const accountEvts = getAccountEvts(evts.slice(-4))
+    expect(accountEvts.length).toBe(2)
+    verifyAccountEvent(accountEvts[0], baddie1, false, AccountStatus.Deleted)
+    verifyAccountEvent(accountEvts[1], baddie2, false, AccountStatus.Deleted)
   })
 
   it('account deletions invalidate all seq ops', async () => {

package/tests/sync/sync.test.ts

@@ -18,6 +18,7 @@ describe('repo sync', () => {
   const uris: AtUri[] = []
   const storage = new MemoryBlockstore()
   let currRoot: CID | undefined
+  let currRev: string | undefined
 
   beforeAll(async () => {
     network = await TestNetworkNoAppView.create({
@@ -64,6 +65,7 @@ describe('repo sync', () => {
     expect(contents).toEqual(repoData)
 
     currRoot = car.root
+    currRev = loaded.commit.rev
   })
 
   it('syncs creates and deletes', async () => {
@@ -101,6 +103,16 @@ describe('repo sync', () => {
     expect(contents).toEqual(repoData)
 
     currRoot = car.root
+    currRev = loaded.commit.rev
+  })
+
+  it('syncs repo status', async () => {
+    const status = await agent.api.com.atproto.sync.getRepoStatus({ did })
+    expect(status.data).toEqual({
+      did,
+      active: true,
+      rev: currRev,
+    })
   })
 
   it('syncs latest repo commit', async () => {
@@ -211,15 +223,47 @@ describe('repo sync', () => {
       )
     })
 
+    afterAll(async () => {
+      await agent.api.com.atproto.admin.updateSubjectStatus(
+        {
+          subject: {
+            $type: 'com.atproto.admin.defs#repoRef',
+            did,
+          },
+          takedown: { applied: false },
+        },
+        {
+          encoding: 'application/json',
+          headers: network.pds.adminAuthHeaders(),
+        },
+      )
+    })
+
+    it('returns takendown status', async () => {
+      const res = await agent.api.com.atproto.sync.getRepoStatus({ did })
+      expect(res.data).toEqual({
+        did,
+        active: false,
+        status: 'takendown',
+      })
+    })
+
+    it('lists as takendown in listRepos', async () => {
+      const res = await agent.api.com.atproto.sync.listRepos()
+      const found = res.data.repos.find((r) => r.did === did)
+      expect(found?.active).toBe(false)
+      expect(found?.status).toBe('takendown')
+    })
+
     it('does not sync repo unauthed', async () => {
       const tryGetRepo = agent.api.com.atproto.sync.getRepo({ did })
-      await expect(tryGetRepo).rejects.toThrow(/Could not find repo for DID/)
+      await expect(tryGetRepo).rejects.toThrow(/Repo has been takendown/)
     })
 
     it('syncs repo to owner or admin', async () => {
       const tryGetRepoOwner = agent.api.com.atproto.sync.getRepo(
         { did },
-        { headers: { authorization: `Bearer ${sc.accounts[did].accessJwt}` } },
+        { headers: sc.getHeaders(did) },
       )
       await expect(tryGetRepoOwner).resolves.toBeDefined()
       const tryGetRepoAdmin = agent.api.com.atproto.sync.getRepo(
@@ -231,7 +275,7 @@ describe('repo sync', () => {
 
     it('does not sync latest commit unauthed', async () => {
       const tryGetLatest = agent.api.com.atproto.sync.getLatestCommit({ did })
-      await expect(tryGetLatest).rejects.toThrow(/Could not find root for DID/)
+      await expect(tryGetLatest).rejects.toThrow(/Repo has been takendown/)
     })
 
     it('does not sync a record proof unauthed', async () => {
@@ -242,7 +286,7 @@ describe('repo sync', () => {
         collection,
         rkey,
       })
-      await expect(tryGetRecord).rejects.toThrow(/Could not find repo for DID/)
+      await expect(tryGetRecord).rejects.toThrow(/Repo has been takendown/)
     })
   })
 })