@atproto/bsky 0.0.251 → 0.0.254

package/tests/views/author-feed.test.ts

@@ -1,694 +0,0 @@
-import assert from 'node:assert'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import {
-  AppBskyActorProfile,
-  AppBskyEmbedGallery,
-  AppBskyEmbedImages,
-  AppBskyEmbedRecordWithMedia,
-  AppBskyEmbedVideo,
-  AppBskyFeedDefs,
-  AppBskyFeedGetAuthorFeed,
-  AppBskyFeedPost,
-  AtpAgent,
-  asPredicate,
-  ids,
-} from '@atproto/api'
-import { SeedClient, TestNetwork, authorFeedSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { uriToDid } from '../../src/util/uris.js'
-import {
-  forSnapshot,
-  paginateAll,
-  stripViewer,
-  stripViewerFromPost,
-} from '../_util.js'
-
-const isValidReplyRef = asPredicate(AppBskyFeedPost.validateReplyRef)
-const isValidProfile = asPredicate(AppBskyActorProfile.validateRecord)
-
-describe('pds author feed views', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let pdsAgent: AtpAgent
-  let sc: SeedClient
-
-  // account dids, for convenience
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-  let dan: DidString
-  let eve: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_author_feed',
-    })
-    agent = network.bsky.getAgent()
-    pdsAgent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await authorFeedSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-    dan = sc.dids.dan
-    eve = sc.dids.eve
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  // @TODO(bsky) blocked by actor takedown via labels.
-  // @TODO(bsky) blocked by record takedown via labels.
-
-  it('fetches full author feeds for self (sorted, minimal viewer state).', async () => {
-    const aliceForAlice = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[alice].handle },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(forSnapshot(aliceForAlice.data.feed)).toMatchSnapshot()
-
-    const bobForBob = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[bob].handle },
-      {
-        headers: await network.serviceHeaders(
-          bob,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(forSnapshot(bobForBob.data.feed)).toMatchSnapshot()
-
-    const carolForCarol = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[carol].handle },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(forSnapshot(carolForCarol.data.feed)).toMatchSnapshot()
-
-    const danForDan = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[dan].handle },
-      {
-        headers: await network.serviceHeaders(
-          dan,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(forSnapshot(danForDan.data.feed)).toMatchSnapshot()
-  })
-
-  it("reflects fetching user's state in the feed.", async () => {
-    const aliceForCarol = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[alice].handle },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    aliceForCarol.data.feed.forEach((postView) => {
-      const { viewer, uri } = postView.post
-      expect(viewer?.like).toEqual(sc.likes[carol][uri]?.toString())
-      expect(viewer?.repost).toEqual(sc.reposts[carol][uri]?.toString())
-    })
-
-    expect(forSnapshot(aliceForCarol.data.feed)).toMatchSnapshot()
-  })
-
-  it('paginates', async () => {
-    const results = (results: AppBskyFeedGetAuthorFeed.OutputSchema[]) =>
-      results.flatMap((res) => res.feed)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.app.bsky.feed.getAuthorFeed(
-        {
-          actor: sc.accounts[alice].handle,
-          cursor,
-          limit: 2,
-        },
-        {
-          headers: await network.serviceHeaders(
-            dan,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator)
-    paginatedAll.forEach((res) =>
-      expect(res.feed.length).toBeLessThanOrEqual(2),
-    )
-
-    const full = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[alice].handle },
-      {
-        headers: await network.serviceHeaders(
-          dan,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(full.data.feed.length).toEqual(4)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-
-  it('fetches results unauthed.', async () => {
-    const { data: authed } = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: sc.accounts[alice].handle },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-    const { data: unauthed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: sc.accounts[alice].handle,
-    })
-    expect(unauthed.feed.length).toBeGreaterThan(0)
-    expect(unauthed.feed).toEqual(
-      authed.feed.map((item) => {
-        const result = {
-          ...item,
-          post: stripViewerFromPost(item.post),
-        }
-        if (item.reply) {
-          result.reply = {
-            parent: stripViewerFromPost(item.reply.parent, true),
-            root: stripViewerFromPost(item.reply.root, true),
-            grandparentAuthor:
-              item.reply.grandparentAuthor &&
-              stripViewer(item.reply.grandparentAuthor),
-          }
-        }
-        return result
-      }),
-    )
-  })
-
-  it('non-admins blocked by actor takedown.', async () => {
-    const { data: preBlock } = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(preBlock.feed.length).toBeGreaterThan(0)
-
-    await network.bsky.ctx.dataplane.takedownActor({
-      did: alice,
-    })
-
-    const attemptAsUser = agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-    await expect(attemptAsUser).rejects.toThrow('Profile not found')
-
-    const attemptAsAdmin = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: alice },
-      { headers: network.bsky.adminAuthHeaders() },
-    )
-    expect(attemptAsAdmin.data.feed.length).toEqual(preBlock.feed.length)
-
-    // Cleanup
-    await network.bsky.ctx.dataplane.untakedownActor({
-      did: alice,
-    })
-  })
-
-  it('blocked by record takedown.', async () => {
-    const { data: preBlock } = await agent.api.app.bsky.feed.getAuthorFeed(
-      { actor: alice },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetAuthorFeed,
-        ),
-      },
-    )
-
-    expect(preBlock.feed.length).toBeGreaterThan(0)
-
-    const post = preBlock.feed[0].post
-
-    await network.bsky.ctx.dataplane.takedownRecord({
-      recordUri: post.uri,
-    })
-
-    const [{ data: postBlockAsUser }, { data: postBlockAsAdmin }] =
-      await Promise.all([
-        agent.api.app.bsky.feed.getAuthorFeed(
-          { actor: alice },
-          {
-            headers: await network.serviceHeaders(
-              carol,
-              ids.AppBskyFeedGetAuthorFeed,
-            ),
-          },
-        ),
-        agent.api.app.bsky.feed.getAuthorFeed(
-          { actor: alice },
-          { headers: network.bsky.adminAuthHeaders() },
-        ),
-      ])
-
-    expect(postBlockAsUser.feed.length).toEqual(preBlock.feed.length - 1)
-    expect(postBlockAsUser.feed.map((item) => item.post.uri)).not.toContain(
-      post.uri,
-    )
-    expect(postBlockAsAdmin.feed.length).toEqual(preBlock.feed.length)
-    expect(postBlockAsAdmin.feed.map((item) => item.post.uri)).toContain(
-      post.uri,
-    )
-
-    // Cleanup
-    await network.bsky.ctx.dataplane.untakedownRecord({
-      recordUri: post.uri,
-    })
-  })
-
-  it('can filter by posts_with_media', async () => {
-    const { data: carolFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: carol,
-      filter: 'posts_with_media',
-    })
-
-    expect(carolFeed.feed.length).toBeGreaterThan(0)
-    assert(
-      carolFeed.feed.every(({ post }) => {
-        const isRecordWithActorMedia =
-          AppBskyEmbedRecordWithMedia.isView(post.embed) &&
-          AppBskyEmbedImages.isView(post.embed?.media)
-        const isActorMedia = AppBskyEmbedImages.isView(post.embed)
-        const isFromActor = post.author.did === carol
-
-        return (isRecordWithActorMedia || isActorMedia) && isFromActor
-      }),
-    )
-
-    const { data: bobFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: bob,
-      filter: 'posts_with_media',
-    })
-
-    assert(
-      bobFeed.feed.every(({ post }) => {
-        return AppBskyEmbedImages.isView(post.embed) && post.author.did === bob
-      }),
-    )
-
-    const { data: danFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: dan,
-      filter: 'posts_with_media',
-    })
-
-    expect(danFeed.feed.length).toEqual(0)
-  })
-
-  it('can filter by posts_with_video', async () => {
-    const { data: carolFeedBefore } =
-      await agent.api.app.bsky.feed.getAuthorFeed({
-        actor: carol,
-        filter: 'posts_with_video',
-      })
-    expect(carolFeedBefore.feed).toHaveLength(0)
-
-    const { data: video } = await pdsAgent.api.com.atproto.repo.uploadBlob(
-      Buffer.from('notarealvideo'),
-      {
-        headers: sc.getHeaders(sc.dids.carol),
-        encoding: 'video/mp4',
-      },
-    )
-
-    await sc.post(carol, 'video post', undefined, undefined, undefined, {
-      embed: {
-        $type: 'app.bsky.embed.video',
-        video: video.blob,
-        alt: 'alt text',
-        aspectRatio: { height: 3, width: 4 },
-      },
-    })
-    await network.processAll()
-
-    const { data: carolFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: carol,
-      filter: 'posts_with_video',
-    })
-
-    expect(carolFeed.feed).toHaveLength(1)
-    expect(
-      carolFeed.feed.every(({ post }) => {
-        const isRecordWithActorMedia =
-          AppBskyEmbedRecordWithMedia.isView(post.embed) &&
-          AppBskyEmbedVideo.isView(post.embed?.media)
-        const isActorMedia = AppBskyEmbedVideo.isView(post.embed)
-        const isFromActor = post.author.did === carol
-
-        return (isRecordWithActorMedia || isActorMedia) && isFromActor
-      }),
-    ).toBeTruthy()
-
-    const { data: bobFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: bob,
-      filter: 'posts_with_video',
-    })
-
-    expect(
-      bobFeed.feed.every(({ post }) => {
-        return AppBskyEmbedVideo.isView(post.embed) && post.author.did === bob
-      }),
-    ).toBeTruthy()
-
-    const { data: danFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: dan,
-      filter: 'posts_with_video',
-    })
-
-    expect(danFeed.feed.length).toEqual(0)
-  })
-
-  it('includes gallery posts in posts_with_media', async () => {
-    const { data: blob1 } = await pdsAgent.api.com.atproto.repo.uploadBlob(
-      Buffer.from('gallery-image-1'),
-      {
-        headers: sc.getHeaders(sc.dids.dan),
-        encoding: 'image/jpeg',
-      },
-    )
-    const { data: blob2 } = await pdsAgent.api.com.atproto.repo.uploadBlob(
-      Buffer.from('gallery-image-2'),
-      {
-        headers: sc.getHeaders(sc.dids.dan),
-        encoding: 'image/jpeg',
-      },
-    )
-
-    await sc.post(dan, 'gallery post', undefined, undefined, undefined, {
-      embed: {
-        $type: 'app.bsky.embed.gallery',
-        items: [
-          {
-            $type: 'app.bsky.embed.gallery#image',
-            image: blob1.blob,
-            alt: 'first',
-            aspectRatio: { height: 1, width: 1 },
-          },
-          {
-            $type: 'app.bsky.embed.gallery#image',
-            image: blob2.blob,
-            alt: 'second',
-            aspectRatio: { height: 1, width: 1 },
-          },
-        ],
-      },
-    })
-    await network.processAll()
-
-    const { data: danFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: dan,
-      filter: 'posts_with_media',
-    })
-
-    expect(danFeed.feed.length).toEqual(1)
-    assert(AppBskyEmbedGallery.isView(danFeed.feed[0].post.embed))
-  })
-
-  it('filters by posts_no_replies', async () => {
-    const { data: carolFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: carol,
-      filter: 'posts_no_replies',
-    })
-
-    assert(
-      carolFeed.feed.every(({ post }) => {
-        return (
-          (AppBskyFeedPost.isRecord(post.record) && !post.record.reply) ||
-          (AppBskyFeedPost.isRecord(post.record) && post.record.reply)
-        )
-      }),
-    )
-
-    const { data: danFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: dan,
-      filter: 'posts_no_replies',
-    })
-
-    expect(
-      danFeed.feed.every(({ post }) => {
-        return (
-          (AppBskyFeedPost.isRecord(post.record) && !post.record.reply) ||
-          (AppBskyFeedPost.isRecord(post.record) && post.record.reply)
-        )
-      }),
-    ).toBeTruthy()
-  })
-
-  it('posts_and_author_threads includes self-replies', async () => {
-    const { data: eveFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
-      actor: eve,
-      filter: 'posts_and_author_threads',
-    })
-
-    expect(eveFeed.feed.length).toEqual(6)
-    expect(
-      eveFeed.feed.some(({ post }) => {
-        const replyByEve =
-          AppBskyFeedPost.isRecord(post.record) &&
-          post.record.reply &&
-          post.author.did === eve
-        return replyByEve
-      }),
-    ).toBeTruthy()
-    // does not include eve's replies to fred, even within her own thread.
-    expect(
-      eveFeed.feed.every(({ post, reply }) => {
-        if (
-          !post ||
-          !AppBskyFeedPost.isRecord(post.record) ||
-          !isValidReplyRef(post.record.reply)
-        ) {
-          return true // not a reply
-        }
-        const replyToEve = isReplyTo(post.record.reply, eve)
-        const replyToReplyByEve =
-          reply &&
-          AppBskyFeedDefs.isPostView(reply.parent) &&
-          AppBskyFeedPost.isRecord(reply.parent.record) &&
-          (!isValidReplyRef(reply.parent.record.reply) ||
-            isReplyTo(reply.parent.record.reply, eve))
-        return replyToEve && replyToReplyByEve
-      }),
-    ).toBeTruthy()
-    // reposts are preserved
-    expect(
-      eveFeed.feed.some(({ post, reason }) => {
-        const repostOfOther =
-          reason &&
-          AppBskyFeedPost.isRecord(post.record) &&
-          post.author.did !== eve
-        return repostOfOther
-      }),
-    ).toBeTruthy()
-  })
-
-  describe('pins', () => {
-    async function createAndPinPost() {
-      const post = await sc.post(alice, 'pinned post')
-      await network.processAll()
-
-      const profile = await pdsAgent.com.atproto.repo.getRecord({
-        repo: alice,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-
-      assert(isValidProfile(profile.data.value))
-
-      const newProfile: AppBskyActorProfile.Record = {
-        ...profile.data.value,
-        pinnedPost: {
-          uri: post.ref.uriStr,
-          cid: post.ref.cid.toString(),
-        },
-      }
-
-      await sc.updateProfile(alice, newProfile)
-
-      await network.processAll()
-
-      return post
-    }
-
-    it('params.includePins = true, pin is in first page of results', async () => {
-      await sc.post(alice, 'not pinned post')
-      const post = await createAndPinPost()
-      await sc.post(alice, 'not pinned post')
-      await network.processAll()
-      const { data } = await agent.api.app.bsky.feed.getAuthorFeed(
-        { actor: sc.accounts[alice].handle, includePins: true },
-        {
-          headers: await network.serviceHeaders(
-            alice,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-
-      const pinnedPosts = data.feed.filter(
-        (item) => item.post.uri === post.ref.uriStr,
-      )
-      expect(pinnedPosts.length).toEqual(1)
-
-      const pinnedPost = data.feed.at(0)
-      expect(pinnedPost?.post?.uri).toEqual(post.ref.uriStr)
-      assert(pinnedPost?.post?.viewer?.pinned)
-      assert(AppBskyFeedDefs.isReasonPin(pinnedPost?.reason))
-
-      const notPinnedPost = data.feed.at(1)
-      expect(notPinnedPost?.post?.viewer?.pinned).toBeFalsy()
-      expect(forSnapshot(data.feed)).toMatchSnapshot()
-    })
-
-    it('params.includePins = true, pin is NOT in first page of results', async () => {
-      const post = await createAndPinPost()
-      await sc.post(alice, 'not pinned post')
-      await sc.post(alice, 'not pinned post')
-      await network.processAll()
-      const { data: page1 } = await agent.api.app.bsky.feed.getAuthorFeed(
-        { actor: sc.accounts[alice].handle, includePins: true, limit: 2 },
-        {
-          headers: await network.serviceHeaders(
-            alice,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-
-      // exists with `reason`
-      const pinnedPost = page1.feed.find(
-        (item) => item.post.uri === post.ref.uriStr,
-      )
-      expect(pinnedPost?.post?.uri).toEqual(post.ref.uriStr)
-      assert(pinnedPost?.post?.viewer?.pinned)
-      assert(AppBskyFeedDefs.isReasonPin(pinnedPost?.reason))
-      expect(forSnapshot(page1.feed)).toMatchSnapshot()
-
-      const { data: page2 } = await agent.api.app.bsky.feed.getAuthorFeed(
-        {
-          actor: sc.accounts[alice].handle,
-          includePins: true,
-          cursor: page1.cursor,
-        },
-        {
-          headers: await network.serviceHeaders(
-            alice,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-
-      // exists without `reason`
-      const laterPinnedPost = page2.feed.find(
-        (item) => item.post.uri === post.ref.uriStr,
-      )
-      expect(laterPinnedPost?.post?.uri).toEqual(post.ref.uriStr)
-      assert(laterPinnedPost?.post?.viewer?.pinned)
-      expect(AppBskyFeedDefs.isReasonPin(laterPinnedPost?.reason)).toBeFalsy()
-      expect(forSnapshot(page2.feed)).toMatchSnapshot()
-    })
-
-    it('params.includePins = false', async () => {
-      const post = await createAndPinPost()
-      const { data } = await agent.api.app.bsky.feed.getAuthorFeed(
-        { actor: sc.accounts[alice].handle },
-        {
-          headers: await network.serviceHeaders(
-            alice,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-
-      // exists without `reason`
-      const pinnedPost = data.feed.find(
-        (item) => item.post.uri === post.ref.uriStr,
-      )
-      expect(AppBskyFeedDefs.isReasonPin(pinnedPost?.reason)).toBeFalsy()
-      expect(forSnapshot(data.feed)).toMatchSnapshot()
-    })
-
-    it("cannot pin someone else's post", async () => {
-      const bobPost = await sc.post(bob, 'pinned post')
-      await sc.post(alice, 'not pinned post')
-      await network.processAll()
-
-      const profile = await pdsAgent.com.atproto.repo.getRecord({
-        repo: alice,
-        collection: 'app.bsky.actor.profile',
-        rkey: 'self',
-      })
-
-      assert(isValidProfile(profile.data.value))
-
-      const newProfile: AppBskyActorProfile.Record = {
-        ...profile.data.value,
-        pinnedPost: {
-          uri: bobPost.ref.uriStr,
-          cid: bobPost.ref.cid.toString(),
-        },
-      }
-
-      await sc.updateProfile(alice, newProfile)
-
-      await network.processAll()
-
-      const { data } = await agent.api.app.bsky.feed.getAuthorFeed(
-        { actor: sc.accounts[alice].handle },
-        {
-          headers: await network.serviceHeaders(
-            alice,
-            ids.AppBskyFeedGetAuthorFeed,
-          ),
-        },
-      )
-
-      const pinnedPost = data.feed.find(
-        (item) => item.post.uri === bobPost.ref.uriStr,
-      )
-      expect(pinnedPost).toBeUndefined()
-      expect(forSnapshot(data.feed)).toMatchSnapshot()
-    })
-  })
-})
-
-function isReplyTo(reply: AppBskyFeedPost.ReplyRef, did: string) {
-  return uriToDid(reply.root.uri) === did && uriToDid(reply.parent.uri) === did
-}