@atproto/bsky 0.0.250 → 0.0.253

package/tests/data-plane/db.test.ts

@@ -1,189 +0,0 @@
-import { sql } from 'kysely'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { wait } from '@atproto/common'
-import { TestNetwork } from '@atproto/dev-env'
-import { Database } from '../../src/index.js'
-
-describe('db', () => {
-  let network: TestNetwork
-  let db: Database
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_db',
-    })
-    db = network.bsky.db
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('handles client errors without crashing.', async () => {
-    const tryKillConnection = db.transaction(async (dbTxn) => {
-      const result = await sql`select pg_backend_pid() as pid;`.execute(
-        dbTxn.db,
-      )
-      const pid = result.rows[0]?.['pid'] as number
-      await sql`select pg_terminate_backend(${pid});`.execute(db.db)
-      await sql`select 1;`.execute(dbTxn.db)
-    })
-    // This should throw, but no unhandled error
-    await expect(tryKillConnection).rejects.toThrow()
-  })
-
-  it('handles pool errors without crashing.', async () => {
-    const conn1 = await db.pool.connect()
-    const conn2 = await db.pool.connect()
-    const result = await conn1.query('select pg_backend_pid() as pid;')
-    const conn1pid: number = result.rows[0].pid
-    conn1.release()
-    await wait(100) // let release apply, conn is now idle on pool.
-    await conn2.query(`select pg_terminate_backend(${conn1pid});`)
-    conn2.release()
-  })
-
-  describe('transaction()', () => {
-    it('commits changes', async () => {
-      const result = await db.transaction(async (dbTxn) => {
-        return await dbTxn.db
-          .insertInto('actor')
-          .values({
-            did: 'x',
-            handle: 'x',
-            indexedAt: 'bad-date',
-          })
-          .returning('did')
-          .executeTakeFirst()
-      })
-
-      if (!result) {
-        return expect(result).toBeTruthy()
-      }
-
-      expect(result.did).toEqual('x')
-
-      const row = await db.db
-        .selectFrom('actor')
-        .select(['did', 'handle', 'indexedAt'])
-        .where('did', '=', 'x')
-        .executeTakeFirst()
-
-      expect(row).toEqual({
-        did: 'x',
-        handle: 'x',
-        indexedAt: 'bad-date',
-      })
-    })
-
-    it('rolls-back changes on failure', async () => {
-      const promise = db.transaction(async (dbTxn) => {
-        await dbTxn.db
-          .insertInto('actor')
-          .values({
-            did: 'y',
-            handle: 'y',
-            indexedAt: 'bad-date',
-          })
-          .returning('did')
-          .executeTakeFirst()
-
-        throw new Error('Oops!')
-      })
-
-      await expect(promise).rejects.toThrow('Oops!')
-
-      const row = await db.db
-        .selectFrom('actor')
-        .selectAll()
-        .where('did', '=', 'y')
-        .executeTakeFirst()
-
-      expect(row).toBeUndefined()
-    })
-
-    it('indicates isTransaction', async () => {
-      expect(db.isTransaction).toEqual(false)
-
-      await db.transaction(async (dbTxn) => {
-        expect(db.isTransaction).toEqual(false)
-        expect(dbTxn.isTransaction).toEqual(true)
-      })
-
-      expect(db.isTransaction).toEqual(false)
-    })
-
-    it('asserts transaction', async () => {
-      expect(() => db.assertTransaction()).toThrow('Transaction required')
-
-      await db.transaction(async (dbTxn) => {
-        expect(() => dbTxn.assertTransaction()).not.toThrow()
-      })
-    })
-
-    it('does not allow leaky transactions', async () => {
-      let leakedTx: Database | undefined
-
-      const tx = db.transaction(async (dbTxn) => {
-        leakedTx = dbTxn
-        await dbTxn.db
-          .insertInto('actor')
-          .values({ handle: 'a', did: 'a', indexedAt: 'bad-date' })
-          .execute()
-        throw new Error('test tx failed')
-      })
-      await expect(tx).rejects.toThrow('test tx failed')
-
-      const attempt = leakedTx?.db
-        .insertInto('actor')
-        .values({ handle: 'b', did: 'b', indexedAt: 'bad-date' })
-        .execute()
-      await expect(attempt).rejects.toThrow('tx already failed')
-
-      const res = await db.db
-        .selectFrom('actor')
-        .selectAll()
-        .where('did', 'in', ['a', 'b'])
-        .execute()
-
-      expect(res.length).toBe(0)
-    })
-
-    it('ensures all inflight queries are rolled back', async () => {
-      let promise: Promise<unknown> | undefined = undefined
-      const names: string[] = []
-      try {
-        await db.transaction(async (dbTxn) => {
-          const queries: Promise<unknown>[] = []
-          for (let i = 0; i < 20; i++) {
-            const name = `user${i}`
-            const query = dbTxn.db
-              .insertInto('actor')
-              .values({
-                handle: name,
-                did: name,
-                indexedAt: 'bad-date',
-              })
-              .execute()
-            names.push(name)
-            queries.push(query)
-          }
-          promise = Promise.allSettled(queries)
-          throw new Error()
-        })
-      } catch (err) {
-        expect(err).toBeDefined()
-      }
-      if (promise) {
-        await promise
-      }
-
-      const res = await db.db
-        .selectFrom('actor')
-        .selectAll()
-        .where('did', 'in', names)
-        .execute()
-      expect(res.length).toBe(0)
-    })
-  })
-})

package/tests/data-plane/duplicate-records.test.ts

@@ -1,156 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { ids } from '@atproto/api'
-import { TID, cidForCbor } from '@atproto/common'
-import { TestNetwork } from '@atproto/dev-env'
-import { WriteOpAction } from '@atproto/repo'
-import { AtUri } from '@atproto/syntax'
-
-type Database = TestNetwork['bsky']['db']
-
-describe('duplicate record', () => {
-  let network: TestNetwork
-  let did: string
-  let db: Database
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_duplicates',
-    })
-    db = network.bsky.db
-    did = 'did:example:alice'
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const countRecords = async (db: Database, table: string) => {
-    const got = await db.db
-      .selectFrom(table as any)
-      .selectAll()
-      .where('creator', '=', did)
-      .execute()
-    return got.length
-  }
-
-  it('dedupes reposts', async () => {
-    const subject = AtUri.make(did, ids.AppBskyFeedPost, TID.nextStr())
-    const subjectCid = await cidForCbor({ test: 'blah' })
-    const coll = ids.AppBskyFeedRepost
-    const uris: AtUri[] = []
-    for (let i = 0; i < 5; i++) {
-      const repost = {
-        $type: coll,
-        subject: {
-          uri: subject.toString(),
-          cid: subjectCid.toString(),
-        },
-        createdAt: new Date().toISOString(),
-      }
-      const uri = AtUri.make(did, coll, TID.nextStr())
-      const cid = await cidForCbor(repost)
-      await network.bsky.sub.indexingSvc.indexRecord(
-        uri,
-        cid,
-        repost,
-        WriteOpAction.Create,
-        repost.createdAt,
-      )
-      uris.push(uri)
-    }
-
-    let count = await countRecords(db, 'repost')
-    expect(count).toBe(1)
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[0], false)
-
-    count = await countRecords(db, 'repost')
-    expect(count).toBe(1)
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[1], true)
-
-    count = await countRecords(db, 'repost')
-    expect(count).toBe(0)
-  })
-
-  it('dedupes like', async () => {
-    const subject = AtUri.make(did, ids.AppBskyFeedPost, TID.nextStr())
-    const subjectCid = await cidForCbor({ test: 'blah' })
-    const coll = ids.AppBskyFeedLike
-    const uris: AtUri[] = []
-    for (let i = 0; i < 5; i++) {
-      const like = {
-        $type: coll,
-        subject: {
-          uri: subject.toString(),
-          cid: subjectCid.toString(),
-        },
-        createdAt: new Date().toISOString(),
-      }
-      const uri = AtUri.make(did, coll, TID.nextStr())
-      const cid = await cidForCbor(like)
-      await network.bsky.sub.indexingSvc.indexRecord(
-        uri,
-        cid,
-        like,
-        WriteOpAction.Create,
-        like.createdAt,
-      )
-      uris.push(uri)
-    }
-
-    let count = await countRecords(db, 'like')
-    expect(count).toBe(1)
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[0], false)
-
-    count = await countRecords(db, 'like')
-    expect(count).toBe(1)
-    const got = await db.db
-      .selectFrom('like')
-      .where('creator', '=', did)
-      .selectAll()
-      .executeTakeFirst()
-    expect(got?.uri).toEqual(uris[1].toString())
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[1], true)
-
-    count = await countRecords(db, 'like')
-    expect(count).toBe(0)
-  })
-
-  it('dedupes follows', async () => {
-    const coll = ids.AppBskyGraphFollow
-    const uris: AtUri[] = []
-    for (let i = 0; i < 5; i++) {
-      const follow = {
-        $type: coll,
-        subject: 'did:example:bob',
-        createdAt: new Date().toISOString(),
-      }
-      const uri = AtUri.make(did, coll, TID.nextStr())
-      const cid = await cidForCbor(follow)
-      await network.bsky.sub.indexingSvc.indexRecord(
-        uri,
-        cid,
-        follow,
-        WriteOpAction.Create,
-        follow.createdAt,
-      )
-      uris.push(uri)
-    }
-
-    let count = await countRecords(db, 'follow')
-    expect(count).toBe(1)
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[0], false)
-
-    count = await countRecords(db, 'follow')
-    expect(count).toBe(1)
-
-    await network.bsky.sub.indexingSvc.deleteRecord(uris[1], true)
-
-    count = await countRecords(db, 'follow')
-    expect(count).toBe(0)
-  })
-})

package/tests/data-plane/handle-invalidation.test.ts

@@ -1,153 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { AtpAgent, ids } from '@atproto/api'
-import { DAY } from '@atproto/common'
-import { SeedClient, TestNetwork, usersSeed } from '@atproto/dev-env'
-import { DidString } from '@atproto/syntax'
-
-describe('handle invalidation', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let pdsAgent: AtpAgent
-  let sc: SeedClient
-  let alice: DidString
-  let bob: DidString
-
-  const mockHandles = {}
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_handle_invalidation',
-    })
-    agent = network.bsky.getAgent()
-    pdsAgent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    await network.processAll()
-
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-
-    const origResolve = network.bsky.dataplane.idResolver.handle.resolve
-    network.bsky.dataplane.idResolver.handle.resolve = async (
-      handle: string,
-    ) => {
-      if (mockHandles[handle] === null) {
-        return undefined
-      } else if (mockHandles[handle]) {
-        return mockHandles[handle]
-      }
-      return origResolve(handle)
-    }
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const backdateIndexedAt = async (did: string) => {
-    const TWO_DAYS_AGO = new Date(Date.now() - 2 * DAY).toISOString()
-    await network.bsky.db.db
-      .updateTable('actor')
-      .set({ indexedAt: TWO_DAYS_AGO })
-      .where('did', '=', did)
-      .execute()
-  }
-
-  it('indexes an account with no proper handle', async () => {
-    mockHandles['eve.test'] = null
-    const eveAccnt = await sc.createAccount('eve', {
-      handle: 'eve.test',
-      email: 'eve@test.com',
-      password: 'eve-pass',
-    })
-    await network.processAll()
-
-    const res = await agent.api.app.bsky.actor.getProfile(
-      { actor: eveAccnt.did },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(res.data.handle).toEqual('handle.invalid')
-  })
-
-  it('invalidates out of date handles', async () => {
-    await backdateIndexedAt(alice)
-
-    const aliceHandle = sc.accounts[alice].handle
-    // alice's handle no longer resolves
-    mockHandles[aliceHandle] = null
-    await sc.post(alice, 'blah')
-    await network.processAll()
-    const res = await agent.api.app.bsky.actor.getProfile(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(res.data.handle).toEqual('handle.invalid')
-  })
-
-  it('revalidates an out of date handle', async () => {
-    await backdateIndexedAt(alice)
-    const aliceHandle = sc.accounts[alice].handle
-    // alice's handle no longer resolves
-    delete mockHandles[aliceHandle]
-
-    await sc.post(alice, 'blah')
-    await network.processAll()
-    const res = await agent.api.app.bsky.actor.getProfile(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(res.data.handle).toEqual(sc.accounts[alice].handle)
-  })
-
-  it('deals with handle contention', async () => {
-    await backdateIndexedAt(bob)
-    // make alice lose her handle so that the pds will let bob take her old handle
-    mockHandles['not-alice.test'] = null
-    await network.pds.ctx.accountManager.updateHandle(alice, 'not-alice.test')
-
-    await pdsAgent.api.com.atproto.identity.updateHandle(
-      {
-        handle: sc.accounts[alice].handle,
-      },
-      { headers: sc.getHeaders(bob), encoding: 'application/json' },
-    )
-    await network.processAll()
-
-    const aliceRes = await agent.api.app.bsky.actor.getProfile(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(aliceRes.data.handle).toEqual('handle.invalid')
-
-    const bobRes = await agent.api.app.bsky.actor.getProfile(
-      { actor: bob },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(bobRes.data.handle).toEqual(sc.accounts[alice].handle)
-  })
-})