@atproto/bsky 0.0.76 → 0.0.78

package/tests/views/feed-view-post.test.ts

@@ -0,0 +1,501 @@
+import { AtpAgent, AppBskyFeedDefs, AtUri } from '@atproto/api'
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import { ids } from '../../src/lexicon/lexicons'
+
+/**
+ * The frontend computes feed slices for display using at-most one
+ * `FeedViewPost` slice. If that slice results in an "orphaned" thread e.g.
+ * parent or root is blocked, that slice is tossed out and the next
+ * `FeedViewPost` slice is considered. That process continues until a
+ * contiguous `root -> child` slice can be found.
+ *
+ * For the tests below, we test with up to 4 slices: one root and up to 3
+ * replies. Some tests focus on the first slice, and others ensure that at
+ * least one contiguous slice is returned.
+ */
+const LIMIT = 4
+
+describe('pds thread views', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let pdsAgent: AtpAgent
+  let sc: SeedClient
+
+  // account dids, for convenience
+  let alice: string
+  let bob: string
+  let carol: string
+  let dan: string
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_views_feed_view_post',
+    })
+    agent = network.bsky.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    alice = sc.dids.alice
+    bob = sc.dids.bob
+    carol = sc.dids.carol
+    dan = sc.dids.dan
+
+    await sc.follow(carol, alice)
+    await sc.follow(carol, bob)
+    await sc.follow(carol, dan)
+    await sc.follow(dan, alice)
+    await sc.follow(dan, bob)
+    await sc.follow(dan, carol)
+
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it(`[A] -> [B], A blocks B, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: bob },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceA = timeline.data.feed.find((f) => f.post.uri === A.ref.uriStr)
+    const sliceB = timeline.data.feed.find((f) => f.post.uri === B.ref.uriStr)
+
+    expect(sliceA).toBeDefined()
+    expect(sliceB).toBeDefined()
+
+    if (!sliceA || !sliceB) {
+      throw new Error('sliceA or sliceB is undefined')
+    }
+
+    expect(AppBskyFeedDefs.isBlockedPost(sliceB.reply?.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isBlockedPost(sliceB.reply?.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C], A blocks B, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: bob },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceC = timeline.data.feed.find((f) => f.post.uri === C.ref.uriStr)
+
+    expect(sliceC).toBeDefined()
+    expect(sliceC?.reply).toBeDefined()
+
+    if (!sliceC || !sliceC.reply) {
+      throw new Error('sliceC is undefined')
+    }
+
+    expect(sliceC.reply.parent.uri).toEqual(B.ref.uriStr)
+    expect(sliceC.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceC.reply.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isBlockedPost(sliceC.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C], C blocks A, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: carol },
+      { createdAt: new Date().toISOString(), subject: alice },
+      sc.getHeaders(carol),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      // make sure we process all slices in this test
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceB = timeline.data.feed.find((f) => f.post.uri === B.ref.uriStr)
+    const sliceC = timeline.data.feed.find((f) => f.post.uri === C.ref.uriStr)
+
+    expect(sliceB).toBeUndefined()
+    expect(sliceC).toBeUndefined()
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: carol, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(carol),
+    )
+  })
+
+  it(`[A] -> [B] -> [C], C blocks B, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: carol },
+      { createdAt: new Date().toISOString(), subject: bob },
+      sc.getHeaders(carol),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      // make sure we process all slices in this test
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceA = timeline.data.feed.find((f) => f.post.uri === A.ref.uriStr)
+    const sliceC = timeline.data.feed.find((f) => f.post.uri === C.ref.uriStr)
+
+    expect(sliceA).toBeDefined()
+    expect(sliceC).toBeUndefined()
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: carol, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(carol),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], A blocks C, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: carol },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceD?.reply).toBeDefined()
+
+    if (!sliceD || !sliceD.reply) {
+      throw new Error('sliceD is undefined')
+    }
+
+    expect(sliceD.reply.parent.uri).toEqual(C.ref.uriStr)
+    expect(sliceD.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isBlockedPost(sliceD.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], A blocks C, viewed as D`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: carol },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(dan, ids.AppBskyFeedGetTimeline),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceD?.reply).toBeDefined()
+
+    if (!sliceD || !sliceD.reply) {
+      throw new Error('sliceD is undefined')
+    }
+
+    expect(sliceD.reply.parent.uri).toEqual(C.ref.uriStr)
+    expect(sliceD.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isBlockedPost(sliceD.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], A blocks B, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: bob },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceD?.reply).toBeDefined()
+
+    if (!sliceD || !sliceD.reply) {
+      throw new Error('sliceD is undefined')
+    }
+
+    expect(sliceD.reply.parent.uri).toEqual(C.ref.uriStr)
+    expect(sliceD.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.parent)).toBe(true)
+    /*
+     * We don't walk the reply ancestors past whats available in the ReplyRef
+     */
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], B blocks C, viewed as D`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: bob },
+      { createdAt: new Date().toISOString(), subject: carol },
+      sc.getHeaders(bob),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(dan, ids.AppBskyFeedGetTimeline),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceD?.reply).toBeDefined()
+
+    if (!sliceD || !sliceD.reply) {
+      throw new Error('sliceD is undefined')
+    }
+
+    expect(sliceD.reply.parent.uri).toEqual(C.ref.uriStr)
+    expect(sliceD.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.parent)).toBe(true)
+    /*
+     * We don't walk the reply ancestors past whats available in the ReplyRef
+     */
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: bob, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(bob),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], A blocks D, viewed as C`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: dan },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(
+          carol,
+          ids.AppBskyFeedGetTimeline,
+        ),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+    const sliceC = timeline.data.feed.find((f) => f.post.uri === C.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceC).toBeDefined()
+
+    if (!sliceD || !sliceC) {
+      throw new Error('sliceD or sliceC is undefined')
+    }
+
+    expect(AppBskyFeedDefs.isBlockedPost(sliceD.reply?.root)).toBe(true)
+    expect(AppBskyFeedDefs.isPostView(sliceC.reply?.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isPostView(sliceC.reply?.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+
+  it(`[A] -> [B] -> [C] -> [D], A blocks C, viewed as D, A/B/C are outside first page`, async () => {
+    const A = await sc.post(alice, `A`)
+    await network.processAll()
+    const B = await sc.reply(bob, A.ref, A.ref, `B`)
+    await network.processAll()
+    const C = await sc.reply(carol, A.ref, B.ref, `C`)
+    await network.processAll()
+
+    // push A/B/C to send page of results
+    await sc.post(alice, `Aa`)
+    await sc.post(alice, `Ab`)
+    await sc.post(alice, `Ac`)
+    await sc.post(alice, `Ad`)
+
+    await network.processAll()
+
+    const D = await sc.reply(dan, A.ref, C.ref, `D`)
+    const block = await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: alice },
+      { createdAt: new Date().toISOString(), subject: carol },
+      sc.getHeaders(alice),
+    )
+
+    await network.processAll()
+
+    const timeline = await agent.api.app.bsky.feed.getTimeline(
+      { limit: LIMIT },
+      {
+        headers: await network.serviceHeaders(dan, ids.AppBskyFeedGetTimeline),
+      },
+    )
+
+    const sliceD = timeline.data.feed.find((f) => f.post.uri === D.ref.uriStr)
+    const sliceA = timeline.data.feed.find((f) => f.post.uri === A.ref.uriStr)
+
+    expect(sliceD).toBeDefined()
+    expect(sliceD?.reply).toBeDefined()
+    // not in first page of results
+    expect(sliceA).toBeUndefined()
+
+    if (!sliceD || !sliceD.reply) {
+      throw new Error('sliceD is undefined')
+    }
+
+    expect(sliceD.reply.parent.uri).toEqual(C.ref.uriStr)
+    expect(sliceD.reply.root.uri).toEqual(A.ref.uriStr)
+    expect(AppBskyFeedDefs.isPostView(sliceD.reply.parent)).toBe(true)
+    expect(AppBskyFeedDefs.isBlockedPost(sliceD.reply.root)).toBe(true)
+
+    await pdsAgent.api.app.bsky.graph.block.delete(
+      { repo: alice, rkey: new AtUri(block.uri).rkey },
+      sc.getHeaders(alice),
+    )
+  })
+})

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

@@ -175,4 +175,16 @@ describe('list feed views', () => {
       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)
+  })
 })

package/tests/views/lists.test.ts

@@ -8,7 +8,9 @@ describe('bsky actor likes feed views', () => {
   let agent: AtpAgent
   let sc: SeedClient
 
+  let curateList: string
   let referenceList: string
+  let alice: string
   let eve: string
   let frankie: string
   let greta: string
@@ -35,17 +37,32 @@ describe('bsky actor likes feed views', () => {
       email: 'greta@greta.com',
       password: 'hunter4real',
     })
-    const newList = await sc.createList(
+
+    const newRefList = await sc.createList(
       sc.dids.eve,
       'blah starter pack list!',
       'reference',
     )
-    await sc.addToList(sc.dids.eve, sc.dids.eve, newList)
-    await sc.addToList(sc.dids.eve, sc.dids.bob, newList)
-    await sc.addToList(sc.dids.eve, sc.dids.frankie, newList)
+    const newCurrList = await sc.createList(
+      sc.dids.eve,
+      'blah curate list!',
+      'curate',
+    )
+
+    await sc.addToList(sc.dids.eve, sc.dids.eve, newRefList)
+    await sc.addToList(sc.dids.eve, sc.dids.bob, newRefList)
+    await sc.addToList(sc.dids.eve, sc.dids.frankie, newRefList)
+
+    await sc.addToList(sc.dids.eve, sc.dids.eve, newCurrList)
+    await sc.addToList(sc.dids.eve, sc.dids.bob, newCurrList)
+    await sc.addToList(sc.dids.eve, sc.dids.frankie, newCurrList)
+
     await sc.block(sc.dids.frankie, sc.dids.eve)
+
     await network.processAll()
-    referenceList = newList.uriStr
+    curateList = newCurrList.uriStr
+    referenceList = newRefList.uriStr
+    alice = sc.dids.alice
     eve = sc.dids.eve
     frankie = sc.dids.frankie
     greta = sc.dids.greta
@@ -61,44 +78,92 @@ describe('bsky actor likes feed views', () => {
     const view = await agent.api.app.bsky.graph.getLists({
       actor: eve,
     })
-    expect(view.data.lists.length).toBe(1)
+    expect(view.data.lists.length).toBe(2)
     expect(forSnapshot(view.data.lists)).toMatchSnapshot()
   })
 
   it('does not include users with creator block relationship in reference lists for non-creator, in-list viewers', async () => {
-    const view = await agent.api.app.bsky.graph.getList(
+    const curView = await agent.api.app.bsky.graph.getList(
+      {
+        list: curateList,
+      },
+      {
+        headers: await network.serviceHeaders(frankie, ids.AppBskyGraphGetList),
+      },
+    )
+    expect(curView.data.items.length).toBe(2)
+    expect(forSnapshot(curView.data.items)).toMatchSnapshot()
+
+    const refView = await agent.api.app.bsky.graph.getList(
       { list: referenceList },
       {
         headers: await network.serviceHeaders(frankie, ids.AppBskyGraphGetList),
       },
     )
-    expect(view.data.items.length).toBe(2)
-    expect(forSnapshot(view.data.items)).toMatchSnapshot()
+    expect(refView.data.items.length).toBe(2)
+    expect(forSnapshot(refView.data.items)).toMatchSnapshot()
   })
 
   it('does not include users with creator block relationship in reference lists for non-creator, not-in-list viewers', async () => {
-    const view = await agent.api.app.bsky.graph.getList(
+    const curView = await agent.api.app.bsky.graph.getList(
+      {
+        list: curateList,
+      },
+      { headers: await network.serviceHeaders(greta, ids.AppBskyGraphGetList) },
+    )
+    expect(curView.data.items.length).toBe(2)
+    expect(forSnapshot(curView.data.items)).toMatchSnapshot()
+
+    const refView = await agent.api.app.bsky.graph.getList(
       { list: referenceList },
       { headers: await network.serviceHeaders(greta, ids.AppBskyGraphGetList) },
     )
-    expect(view.data.items.length).toBe(2)
-    expect(forSnapshot(view.data.items)).toMatchSnapshot()
+    expect(refView.data.items.length).toBe(2)
+    expect(forSnapshot(refView.data.items)).toMatchSnapshot()
   })
 
-  it('does not include users with creator block relationship in reference lists for signed-out viewers', async () => {
-    const view = await agent.api.app.bsky.graph.getList({
+  it('does not include users with creator block relationship in reference and curate lists for signed-out viewers', async () => {
+    const curView = await agent.api.app.bsky.graph.getList({
+      list: curateList,
+    })
+    expect(curView.data.items.length).toBe(2)
+    expect(forSnapshot(curView.data.items)).toMatchSnapshot()
+
+    const refView = await agent.api.app.bsky.graph.getList({
       list: referenceList,
     })
-    expect(view.data.items.length).toBe(2)
-    expect(forSnapshot(view.data.items)).toMatchSnapshot()
+    expect(refView.data.items.length).toBe(2)
+    expect(forSnapshot(refView.data.items)).toMatchSnapshot()
   })
 
   it('does include users with creator block relationship in reference lists for creator', async () => {
-    const view = await agent.api.app.bsky.graph.getList(
+    const curView = await agent.api.app.bsky.graph.getList(
+      { list: curateList },
+      { headers: await network.serviceHeaders(eve, ids.AppBskyGraphGetList) },
+    )
+    expect(curView.data.items.length).toBe(3)
+    expect(forSnapshot(curView.data.items)).toMatchSnapshot()
+
+    const refView = await agent.api.app.bsky.graph.getList(
       { list: referenceList },
       { headers: await network.serviceHeaders(eve, ids.AppBskyGraphGetList) },
     )
-    expect(view.data.items.length).toBe(3)
+    expect(refView.data.items.length).toBe(3)
+    expect(forSnapshot(refView.data.items)).toMatchSnapshot()
+  })
+
+  it('does return all users regardless of creator block relationship in moderation lists', async () => {
+    const blockList = await sc.createList(eve, 'block list', 'mod')
+    await sc.addToList(eve, frankie, blockList)
+    await sc.addToList(eve, greta, blockList)
+    await sc.block(frankie, greta)
+    await network.processAll()
+
+    const view = await agent.api.app.bsky.graph.getList(
+      { list: blockList.uriStr },
+      { headers: await network.serviceHeaders(alice, ids.AppBskyGraphGetList) },
+    )
+    expect(view.data.items.length).toBe(2)
     expect(forSnapshot(view.data.items)).toMatchSnapshot()
   })
 })