@atproto/bsky 0.0.251 → 0.0.254

package/tests/views/labels-takedown.test.ts

@@ -1,247 +0,0 @@
-import assert from 'node:assert'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AppBskyLabelerDefs, AtpAgent, ids } from '@atproto/api'
-import { RecordRef, SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-
-describe('bsky takedown labels', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let pdsAgent: AtpAgent
-  let sc: SeedClient
-
-  let takendownSubjects: string[]
-
-  let aliceListRef: RecordRef
-  let carolListRef: RecordRef
-  let aliceGenRef: RecordRef
-  let bobGenRef: RecordRef
-  let carolGenRef: RecordRef
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_takedown_labels',
-    })
-    agent = network.bsky.getAgent()
-    pdsAgent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-
-    aliceListRef = await sc.createList(sc.dids.alice, 'alice list', 'mod')
-    // carol blocks dan via alice's (takendown) list
-    await sc.addToList(sc.dids.alice, sc.dids.dan, aliceListRef)
-    await pdsAgent.app.bsky.graph.listblock.create(
-      { repo: sc.dids.carol },
-      {
-        subject: aliceListRef.uriStr,
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(sc.dids.carol),
-    )
-    carolListRef = await sc.createList(sc.dids.carol, 'carol list', 'mod')
-    // alice blocks dan via carol's list, and carol is takendown
-    await sc.addToList(sc.dids.carol, sc.dids.dan, carolListRef)
-    await pdsAgent.app.bsky.graph.listblock.create(
-      { repo: sc.dids.alice },
-      {
-        subject: carolListRef.uriStr,
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(sc.dids.alice),
-    )
-    aliceGenRef = await sc.createFeedGen(
-      sc.dids.alice,
-      'did:web:example.com',
-      'alice generator',
-    )
-    bobGenRef = await sc.createFeedGen(
-      sc.dids.bob,
-      'did:web:example.com',
-      'bob generator',
-    )
-    carolGenRef = await sc.createFeedGen(
-      sc.dids.carol,
-      'did:web:example.com',
-      'carol generator',
-    )
-
-    // labelers
-    await sc.createAccount('labeler1', {
-      email: 'lab1@test.com',
-      handle: 'lab1.test',
-      password: 'lab1',
-    })
-    await sc.agent.api.com.atproto.repo.createRecord(
-      {
-        repo: sc.dids.labeler1,
-        collection: ids.AppBskyLabelerService,
-        rkey: 'self',
-        record: {
-          policies: { labelValues: ['spam'] },
-          createdAt: new Date().toISOString(),
-        },
-      },
-      {
-        headers: sc.getHeaders(sc.dids.labeler1),
-        encoding: 'application/json',
-      },
-    )
-    await sc.createAccount('labeler2', {
-      email: 'lab2@test.com',
-      handle: 'lab2.test',
-      password: 'lab2',
-    })
-    await sc.agent.api.com.atproto.repo.createRecord(
-      {
-        repo: sc.dids.labeler2,
-        collection: ids.AppBskyLabelerService,
-        rkey: 'self',
-        record: {
-          policies: { labelValues: ['spam'] },
-          createdAt: new Date().toISOString(),
-        },
-      },
-      {
-        headers: sc.getHeaders(sc.dids.labeler2),
-        encoding: 'application/json',
-      },
-    )
-
-    await network.processAll()
-
-    takendownSubjects = [
-      sc.posts[sc.dids.alice][0].ref.uriStr,
-      sc.dids.carol,
-      aliceListRef.uriStr,
-      aliceGenRef.uriStr,
-      sc.dids.labeler1,
-    ]
-    const src = network.ozone.ctx.cfg.service.did
-    const cts = new Date().toISOString()
-    const labels = takendownSubjects.map((uri) => ({
-      src,
-      uri,
-      cid: '',
-      val: '!takedown',
-      exp: null,
-      neg: false,
-      cts,
-    }))
-    AtpAgent.configure({ appLabelers: [src] })
-
-    await network.bsky.db.db.insertInto('label').values(labels).execute()
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  it('takesdown profiles', async () => {
-    const attempt = agent.api.app.bsky.actor.getProfile({
-      actor: sc.dids.carol,
-    })
-    await expect(attempt).rejects.toThrow('Account has been suspended')
-    const res = await agent.api.app.bsky.actor.getProfiles({
-      actors: [sc.dids.alice, sc.dids.bob, sc.dids.carol],
-    })
-    expect(res.data.profiles.length).toBe(2)
-    expect(res.data.profiles.some((p) => p.did === sc.dids.carol)).toBe(false)
-  })
-
-  it('takesdown posts', async () => {
-    const uris = [
-      sc.posts[sc.dids.alice][0].ref.uriStr,
-      sc.posts[sc.dids.alice][1].ref.uriStr,
-      sc.posts[sc.dids.bob][0].ref.uriStr,
-      sc.posts[sc.dids.carol][0].ref.uriStr,
-      sc.posts[sc.dids.dan][1].ref.uriStr,
-      sc.replies[sc.dids.alice][0].ref.uriStr,
-    ]
-    const res = await agent.api.app.bsky.feed.getPosts({ uris })
-
-    expect(res.data.posts.length).toBe(4)
-    expect(res.data.posts.some((p) => p.author.did === sc.dids.carol)).toBe(
-      false,
-    )
-    expect(
-      res.data.posts.some(
-        (p) => p.uri === sc.posts[sc.dids.alice][0].ref.uriStr,
-      ),
-    ).toBe(false)
-  })
-
-  it('takesdown lists', async () => {
-    // record takedown
-    const attempt1 = agent.api.app.bsky.graph.getList({
-      list: aliceListRef.uriStr,
-    })
-    await expect(attempt1).rejects.toThrow('List not found')
-
-    // actor takedown
-    const attempt2 = agent.api.app.bsky.graph.getList({
-      list: carolListRef.uriStr,
-    })
-    await expect(attempt2).rejects.toThrow('List not found')
-  })
-
-  it('halts application of mod lists', async () => {
-    const { data: profile } = await agent.app.bsky.actor.getProfile(
-      {
-        actor: sc.dids.dan, // blocked via alice's takendown list
-      },
-      {
-        headers: await network.serviceHeaders(
-          sc.dids.carol,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(profile.did).toBe(sc.dids.dan)
-    expect(profile.viewer).not.toBeUndefined()
-    expect(profile.viewer?.blockedBy).toBe(false)
-    expect(profile.viewer?.blocking).toBeUndefined()
-    expect(profile.viewer?.blockingByList).toBeUndefined()
-  })
-
-  it('author takedown halts application of mod lists', async () => {
-    const { data: profile } = await agent.app.bsky.actor.getProfile(
-      {
-        actor: sc.dids.dan, // blocked via carol's list, and carol is takendown
-      },
-      {
-        headers: await network.serviceHeaders(
-          sc.dids.alice,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-    expect(profile.did).toBe(sc.dids.dan)
-    expect(profile.viewer).not.toBeUndefined()
-    expect(profile.viewer?.blockedBy).toBe(false)
-    expect(profile.viewer?.blocking).toBeUndefined()
-    expect(profile.viewer?.blockingByList).toBeUndefined()
-  })
-
-  it('takesdown feed generators', async () => {
-    const res = await agent.api.app.bsky.feed.getFeedGenerators({
-      feeds: [aliceGenRef.uriStr, bobGenRef.uriStr, carolGenRef.uriStr],
-    })
-    expect(res.data.feeds.length).toBe(1)
-    expect(res.data.feeds.at(0)?.uri).toEqual(bobGenRef.uriStr)
-  })
-
-  it('takesdown labelers', async () => {
-    const res = await agent.api.app.bsky.labeler.getServices({
-      dids: [sc.dids.labeler1, sc.dids.labeler2],
-    })
-    expect(res.data.views.length).toBe(1)
-    assert(AppBskyLabelerDefs.isLabelerView(res.data.views[0]))
-    expect(res.data.views[0].creator.did).toBe(sc.dids.labeler2)
-  })
-
-  it('only applies if the relevant labeler is configured', async () => {
-    AtpAgent.configure({ appLabelers: ['did:web:example.com'] })
-    const res = await agent.api.app.bsky.actor.getProfile({
-      actor: sc.dids.carol,
-    })
-    expect(res.data.did).toEqual(sc.dids.carol)
-  })
-})

package/tests/views/likes.test.ts

@@ -1,192 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AppBskyFeedGetLikes, AtpAgent, ids } from '@atproto/api'
-import { SeedClient, TestNetwork, likesSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import {
-  constantDate,
-  forSnapshot,
-  paginateAll,
-  stripViewer,
-} from '../_util.js'
-
-describe('pds like views', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  // account dids, for convenience
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-  let frankie: DidString
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_likes',
-    })
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await likesSeed(sc)
-    await sc.createAccount('frankie', {
-      handle: 'frankie.test',
-      email: 'frankie@frankie.com',
-      password: 'password',
-    })
-
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-    frankie = sc.dids.frankie
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  const getCursors = (items: { createdAt?: string }[]) =>
-    items.map((item) => item.createdAt ?? constantDate)
-
-  const getSortedCursors = (items: { createdAt?: string }[]) =>
-    getCursors(items).sort((a, b) => tstamp(b) - tstamp(a))
-
-  const tstamp = (x: string) => new Date(x).getTime()
-
-  it('fetches post likes', async () => {
-    const alicePost = await agent.api.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(forSnapshot(alicePost.data)).toMatchSnapshot()
-    expect(getCursors(alicePost.data.likes)).toEqual(
-      getSortedCursors(alicePost.data.likes),
-    )
-  })
-
-  it('fetches reply likes', async () => {
-    const bobReply = await agent.api.app.bsky.feed.getLikes(
-      { uri: sc.replies[bob][0].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(forSnapshot(bobReply.data)).toMatchSnapshot()
-    expect(getCursors(bobReply.data.likes)).toEqual(
-      getSortedCursors(bobReply.data.likes),
-    )
-  })
-
-  it('paginates', async () => {
-    const results = (results: AppBskyFeedGetLikes.OutputSchema[]) =>
-      results.flatMap((res) => res.likes)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.app.bsky.feed.getLikes(
-        {
-          uri: sc.posts[alice][1].ref.uriStr,
-          cursor,
-          limit: 2,
-        },
-        {
-          headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes),
-        },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator)
-    paginatedAll.forEach((res) =>
-      expect(res.likes.length).toBeLessThanOrEqual(2),
-    )
-
-    const full = await agent.api.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(full.data.likes.length).toEqual(4)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-
-  it('fetches post likes unauthed', async () => {
-    const { data: authed } = await agent.api.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-    const { data: unauthed } = await agent.api.app.bsky.feed.getLikes({
-      uri: sc.posts[alice][1].ref.uriStr,
-    })
-    expect(unauthed.likes.length).toBeGreaterThan(0)
-    expect(unauthed.likes).toEqual(
-      authed.likes.map((like) => {
-        return {
-          ...like,
-          actor: stripViewer(like.actor),
-        }
-      }),
-    )
-  })
-
-  it(`author viewer doesn't see likes by user the author blocked`, async () => {
-    await sc.like(frankie, sc.posts[alice][1].ref)
-    await network.processAll()
-
-    const beforeBlock = await agent.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(beforeBlock.data.likes.map((like) => like.actor.did)).toStrictEqual([
-      sc.dids.frankie,
-      sc.dids.eve,
-      sc.dids.dan,
-      sc.dids.carol,
-      sc.dids.bob,
-    ])
-
-    await sc.block(alice, frankie)
-    await network.processAll()
-
-    const afterBlock = await agent.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(alice, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(afterBlock.data.likes.map((like) => like.actor.did)).toStrictEqual([
-      sc.dids.eve,
-      sc.dids.dan,
-      sc.dids.carol,
-      sc.dids.bob,
-    ])
-  })
-
-  it(`non-author viewer doesn't see likes by user the author blocked and by user the viewer blocked `, async () => {
-    await sc.unblock(alice, frankie)
-    await network.processAll()
-
-    const beforeBlock = await agent.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(bob, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(beforeBlock.data.likes.map((like) => like.actor.did)).toStrictEqual([
-      sc.dids.frankie,
-      sc.dids.eve,
-      sc.dids.dan,
-      sc.dids.carol,
-      sc.dids.bob,
-    ])
-
-    await sc.block(alice, frankie)
-    await sc.block(bob, carol)
-    await network.processAll()
-
-    const afterBlock = await agent.app.bsky.feed.getLikes(
-      { uri: sc.posts[alice][1].ref.uriStr },
-      { headers: await network.serviceHeaders(bob, ids.AppBskyFeedGetLikes) },
-    )
-
-    expect(afterBlock.data.likes.map((like) => like.actor.did)).toStrictEqual([
-      sc.dids.eve,
-      sc.dids.dan,
-      sc.dids.bob,
-    ])
-  })
-})

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

@@ -1,195 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AppBskyFeedGetListFeed, AtpAgent, ids } from '@atproto/api'
-import { RecordRef, SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import {
-  forSnapshot,
-  paginateAll,
-  stripViewer,
-  stripViewerFromPost,
-} from '../_util.js'
-
-describe('list feed views', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  // account dids, for convenience
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-
-  let listRef: RecordRef
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_list_feed',
-    })
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-    listRef = await sc.createList(alice, 'test list', 'curate')
-    await sc.addToList(alice, alice, listRef)
-    await sc.addToList(alice, bob, listRef)
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  it('fetches list feed', async () => {
-    const res = await agent.api.app.bsky.feed.getListFeed(
-      { list: listRef.uriStr },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetListFeed,
-        ),
-      },
-    )
-    expect(forSnapshot(res.data.feed)).toMatchSnapshot()
-
-    // all posts are from alice or bob
-    expect(
-      res.data.feed.every((row) =>
-        [alice, bob].includes(row.post.author.did as DidString),
-      ),
-    ).toBeTruthy()
-  })
-
-  it('paginates', async () => {
-    const results = (results: AppBskyFeedGetListFeed.OutputSchema[]) =>
-      results.flatMap((res) => res.feed)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.app.bsky.feed.getListFeed(
-        {
-          list: listRef.uriStr,
-          cursor,
-          limit: 2,
-        },
-        {
-          headers: await network.serviceHeaders(
-            carol,
-            ids.AppBskyFeedGetListFeed,
-          ),
-        },
-      )
-      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.getListFeed(
-      { list: listRef.uriStr },
-      {
-        headers: await network.serviceHeaders(
-          carol,
-          ids.AppBskyFeedGetListFeed,
-        ),
-      },
-    )
-
-    expect(full.data.feed.length).toEqual(7)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-
-  it('fetches results unauthed', async () => {
-    const { data: authed } = await agent.api.app.bsky.feed.getListFeed(
-      { list: listRef.uriStr },
-      {
-        headers: await network.serviceHeaders(
-          alice,
-          ids.AppBskyFeedGetListFeed,
-        ),
-      },
-    )
-    const { data: unauthed } = await agent.api.app.bsky.feed.getListFeed({
-      list: listRef.uriStr,
-    })
-    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),
-          }
-
-          if (item.reply.grandparentAuthor) {
-            result.reply.grandparentAuthor = stripViewer(
-              item.reply.grandparentAuthor,
-            )
-          }
-        }
-        return result
-      }),
-    )
-  })
-
-  it('works for empty lists', async () => {
-    const emptyList = await sc.createList(alice, 'empty list', 'curate')
-    const res = await agent.api.app.bsky.feed.getListFeed({
-      list: emptyList.uriStr,
-    })
-
-    expect(res.data.feed.length).toEqual(0)
-  })
-
-  it('blocks posts by actor takedown', async () => {
-    await network.bsky.ctx.dataplane.takedownActor({
-      did: bob,
-    })
-
-    const res = await agent.api.app.bsky.feed.getListFeed({
-      list: listRef.uriStr,
-    })
-    const hasBob = res.data.feed.some((item) => item.post.author.did === bob)
-    expect(hasBob).toBe(false)
-
-    // Cleanup
-    await network.bsky.ctx.dataplane.untakedownActor({
-      did: bob,
-    })
-  })
-
-  it('blocks posts by record takedown.', async () => {
-    const postRef = sc.replies[bob][0].ref // Post and reply parent
-    await network.bsky.ctx.dataplane.takedownRecord({
-      recordUri: postRef.uriStr,
-    })
-
-    const res = await agent.api.app.bsky.feed.getListFeed({
-      list: listRef.uriStr,
-    })
-    const hasPost = res.data.feed.some(
-      (item) => item.post.uri === postRef.uriStr,
-    )
-    expect(hasPost).toBe(false)
-
-    // Cleanup
-    await network.bsky.ctx.dataplane.untakedownRecord({
-      recordUri: postRef.uriStr,
-    })
-  })
-
-  it('does not return posts with creator blocks', async () => {
-    await sc.block(bob, alice)
-    await network.processAll()
-
-    const res = await agent.api.app.bsky.feed.getListFeed({
-      list: listRef.uriStr,
-    })
-
-    const hasBob = res.data.feed.some((item) => item.post.author.did === bob)
-    expect(hasBob).toBe(false)
-  })
-})