@atproto/bsky 0.0.251 → 0.0.254

package/tests/views/bookmarks.test.ts

@@ -1,345 +0,0 @@
-import assert from 'node:assert'
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from 'vitest'
-import {
-  $Typed,
-  AppBskyBookmarkCreateBookmark,
-  AppBskyBookmarkDefs,
-  AppBskyBookmarkDeleteBookmark,
-  AppBskyBookmarkGetBookmarks,
-  AppBskyFeedDefs,
-  AtpAgent,
-  ids,
-} from '@atproto/api'
-import { RecordRef, SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { forSnapshot, paginateAll } from '../_util.js'
-
-type Database = TestNetwork['bsky']['db']
-
-describe('appview bookmarks views', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let db: Database
-
-  // account dids, for convenience
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-  let dan: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_bookmarks',
-    })
-    db = network.bsky.db
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-    dan = sc.dids.dan
-  })
-
-  beforeEach(async () => network.processAll())
-
-  afterEach(async () => {
-    vi.resetAllMocks()
-    // Drain pending bsync ops before clearing, so a stale op can't land after
-    // the reset.
-    await network.processAll()
-    await clearPrivateData(db)
-    await clearBookmarks(db)
-  })
-
-  afterAll(async () => network?.close())
-
-  const get = async (actor: string, limit?: number, cursor?: string) =>
-    agent.app.bsky.bookmark.getBookmarks(
-      { limit, cursor },
-      {
-        headers: await network.serviceHeaders(
-          actor,
-          ids.AppBskyBookmarkGetBookmarks,
-        ),
-      },
-    )
-
-  const create = async (actor: string, ref: RecordRef) =>
-    agent.app.bsky.bookmark.createBookmark(
-      { cid: ref.cidStr, uri: ref.uriStr },
-      {
-        headers: await network.serviceHeaders(
-          actor,
-          ids.AppBskyBookmarkCreateBookmark,
-        ),
-      },
-    )
-
-  const del = async (actor: string, ref: RecordRef) =>
-    agent.app.bsky.bookmark.deleteBookmark(
-      { uri: ref.uriStr },
-      {
-        headers: await network.serviceHeaders(
-          actor,
-          ids.AppBskyBookmarkDeleteBookmark,
-        ),
-      },
-    )
-
-  const getPost = async (actor: string, ref: RecordRef) => {
-    const { data } = await agent.app.bsky.feed.getPosts(
-      { uris: [ref.uriStr] },
-      {
-        headers: await network.serviceHeaders(actor, ids.AppBskyFeedGetPosts),
-      },
-    )
-
-    return data.posts[0]
-  }
-
-  describe('creation', () => {
-    it('creates bookmarks', async () => {
-      await create(alice, sc.posts[alice][0].ref)
-      await create(alice, sc.posts[bob][0].ref)
-      await create(alice, sc.posts[carol][0].ref)
-
-      await create(bob, sc.posts[bob][0].ref)
-      await create(bob, sc.posts[carol][0].ref)
-      await network.processAll()
-
-      const { data: dataAlice } = await get(alice)
-      expect(dataAlice.bookmarks).toHaveLength(3)
-
-      const { data: dataBob } = await get(bob)
-      expect(dataBob.bookmarks).toHaveLength(2)
-    })
-
-    it('is idempotent', async () => {
-      const uri = sc.posts[alice][0].ref
-
-      await create(alice, uri)
-      await network.processAll()
-      const { data: data0 } = await get(alice)
-      expect(data0.bookmarks).toHaveLength(1)
-
-      await create(alice, uri)
-      await network.processAll()
-      const { data: data1 } = await get(alice)
-      expect(data1.bookmarks).toHaveLength(1)
-    })
-
-    it('fails on unsupported collections', async () => {
-      const followRef = sc.follows[alice][bob]
-      await expect(create(alice, followRef)).rejects.toThrow(
-        AppBskyBookmarkCreateBookmark.UnsupportedCollectionError,
-      )
-    })
-  })
-
-  describe('deletion', () => {
-    it('removes bookmarks', async () => {
-      await create(alice, sc.posts[alice][0].ref)
-      await create(alice, sc.posts[bob][0].ref)
-      await create(alice, sc.posts[carol][0].ref)
-      await network.processAll()
-
-      const { data: dataBefore } = await get(alice)
-      expect(dataBefore.bookmarks).toHaveLength(3)
-
-      await del(alice, sc.posts[alice][0].ref)
-      await del(alice, sc.posts[carol][0].ref)
-      await network.processAll()
-
-      const { data: dataAfter } = await get(alice)
-      expect(dataAfter.bookmarks).toHaveLength(1)
-    })
-
-    it('is idempotent', async () => {
-      const uri = sc.posts[alice][0].ref
-      await create(alice, uri)
-      // deleteBookmark resolves the bookmark's key from indexed state, so the
-      // create must be indexed before the delete is issued.
-      await network.processAll()
-
-      await del(alice, uri)
-      await network.processAll()
-      const { data: data0 } = await get(alice)
-      expect(data0.bookmarks).toHaveLength(0)
-
-      await del(alice, uri)
-      await network.processAll()
-      const { data: data1 } = await get(alice)
-      expect(data1.bookmarks).toHaveLength(0)
-    })
-
-    it('fails on unsupported collections', async () => {
-      const followRef = sc.follows[alice][bob]
-      await expect(del(alice, followRef)).rejects.toThrow(
-        AppBskyBookmarkDeleteBookmark.UnsupportedCollectionError,
-      )
-    })
-  })
-
-  describe('listing', () => {
-    it('gets empty bookmarks', async () => {
-      const { data } = await get(alice)
-      expect(data.bookmarks).toHaveLength(0)
-    })
-
-    it('includes the bookmarked viewer state', async () => {
-      const ref = sc.posts[bob][0].ref
-
-      const postBefore = await getPost(alice, ref)
-      expect(postBefore.viewer?.bookmarked).toBe(false)
-
-      await create(alice, ref)
-      await network.processAll()
-      const postAfterCreate = await getPost(alice, ref)
-      expect(postAfterCreate.viewer?.bookmarked).toBe(true)
-      const postAfterCreateForBob = await getPost(bob, ref)
-      expect(postAfterCreateForBob.viewer?.bookmarked).toBe(false)
-
-      await del(alice, ref)
-      await network.processAll()
-      const postAfterDel = await getPost(alice, ref)
-      expect(postAfterDel.viewer?.bookmarked).toBe(false)
-    })
-
-    it('includes the bookmark counts', async () => {
-      const uri = sc.posts[bob][0].ref
-
-      const postBefore = await getPost(alice, uri)
-      expect(postBefore.bookmarkCount).toBe(0)
-
-      await create(alice, uri)
-      await create(carol, uri)
-      await network.processAll()
-      const postAfterCreate = await getPost(alice, uri)
-      expect(postAfterCreate.bookmarkCount).toBe(2)
-      const postAfterCreateForBob = await getPost(bob, uri)
-      expect(postAfterCreateForBob.bookmarkCount).toBe(2)
-
-      await del(alice, uri)
-      await network.processAll()
-      const postAfterAliceDel = await getPost(alice, uri)
-      expect(postAfterAliceDel.bookmarkCount).toBe(1)
-
-      await del(carol, uri)
-      await network.processAll()
-      const postAfterCarolDel = await getPost(carol, uri)
-      expect(postAfterCarolDel.bookmarkCount).toBe(0)
-    })
-
-    it('paginates bookmarks in descending order', async () => {
-      await create(alice, sc.posts[alice][0].ref)
-      await create(alice, sc.posts[alice][1].ref)
-      await create(alice, sc.posts[bob][0].ref)
-      await create(alice, sc.posts[bob][1].ref)
-      await create(alice, sc.posts[carol][0].ref)
-      await create(alice, sc.posts[dan][0].ref)
-      await create(alice, sc.posts[dan][1].ref)
-      await network.processAll()
-
-      const results = (out: AppBskyBookmarkGetBookmarks.OutputSchema[]) =>
-        out.flatMap((res) => res.bookmarks)
-
-      const paginator = async (cursor?: string) => {
-        const res = await get(alice, 2, cursor)
-        return res.data
-      }
-
-      const fullRes = await get(alice)
-      expect(fullRes.data.bookmarks.length).toBe(7)
-
-      const paginatedRes = await paginateAll(paginator)
-      paginatedRes.forEach((res) =>
-        expect(res.bookmarks.length).toBeLessThanOrEqual(2),
-      )
-
-      const full = results([fullRes.data])
-      assertPostViews(full)
-
-      const paginated = results(paginatedRes)
-      assertPostViews(paginated)
-
-      // Check items are the same.
-      const sort = (
-        a: { item: $Typed<AppBskyFeedDefs.PostView> },
-        b: { item: $Typed<AppBskyFeedDefs.PostView> },
-      ) => (a.item.uri > b.item.uri ? 1 : -1)
-      expect([...paginated].sort(sort)).toEqual([...full].sort(sort))
-
-      // Check pagination ordering.
-      expect(paginated.at(0)?.subject).toStrictEqual({
-        uri: sc.posts[dan][1].ref.uriStr,
-        cid: sc.posts[dan][1].ref.cidStr,
-      })
-      expect(paginated.at(-1)?.subject).toStrictEqual({
-        uri: sc.posts[alice][0].ref.uriStr,
-        cid: sc.posts[alice][0].ref.cidStr,
-      })
-    })
-
-    it('shows posts and blocked posts correctly', async () => {
-      await create(alice, sc.posts[alice][0].ref)
-      await create(alice, sc.posts[bob][0].ref)
-      await create(alice, sc.posts[carol][0].ref)
-
-      await create(bob, sc.posts[alice][0].ref)
-      await create(bob, sc.posts[carol][0].ref)
-
-      await sc.block(alice, bob)
-      await network.processAll()
-
-      const {
-        data: { bookmarks: bookmarksA },
-      } = await get(alice)
-      expect(bookmarksA).toHaveLength(3)
-      expect(bookmarksA[0].item.$type).toBe('app.bsky.feed.defs#postView')
-      expect(bookmarksA[1].item.$type).toBe('app.bsky.feed.defs#blockedPost')
-      expect(bookmarksA[2].item.$type).toBe('app.bsky.feed.defs#postView')
-      expect(forSnapshot(bookmarksA)).toMatchSnapshot()
-
-      const {
-        data: { bookmarks: bookmarksB },
-      } = await get(bob)
-      expect(bookmarksB).toHaveLength(2)
-      expect(bookmarksB[0].item.$type).toBe('app.bsky.feed.defs#postView')
-      expect(bookmarksB[1].item.$type).toBe('app.bsky.feed.defs#blockedPost')
-      expect(forSnapshot(bookmarksB)).toMatchSnapshot()
-    })
-  })
-})
-
-const clearPrivateData = async (db: Database) => {
-  await db.db.deleteFrom('private_data').execute()
-}
-
-const clearBookmarks = async (db: Database) => {
-  await db.db.deleteFrom('bookmark').execute()
-}
-
-function assertPostViews(
-  bookmarks: AppBskyBookmarkGetBookmarks.OutputSchema['bookmarks'],
-): asserts bookmarks is (AppBskyBookmarkDefs.BookmarkView & {
-  item: $Typed<AppBskyFeedDefs.PostView>
-})[] {
-  bookmarks.forEach((b) => {
-    assert(
-      AppBskyFeedDefs.isPostView(b.item),
-      `Expected bookmark to be a post view`,
-    )
-  })
-}