@atproto/bsky 0.0.151 → 0.0.152

package/tests/seed/thread-v2.ts

@@ -0,0 +1,775 @@
+import { AppBskyFeedPost } from '@atproto/api'
+import {
+  RecordRef,
+  SeedClient,
+  TestNetwork,
+  TestNetworkNoAppView,
+} from '@atproto/dev-env'
+import { User, createUsers } from './util'
+
+type ReplyFn = (
+  replyAuthor: User,
+  overridesOrCb?: Partial<AppBskyFeedPost.Record> | ReplyCb,
+  maybeReplyCb?: ReplyCb,
+) => Promise<void>
+
+type ReplyCb = (r: ReplyFn) => Promise<void>
+
+const rootReplyFnBuilder = <T extends TestNetworkNoAppView>(
+  sc: SeedClient<T>,
+  root: RecordRef,
+  parent: RecordRef,
+  prevBreadcrumbs: string,
+  posts: Record<
+    string,
+    | Awaited<ReturnType<SeedClient['post']>>
+    | Awaited<ReturnType<SeedClient['reply']>>
+  >,
+): ReplyFn => {
+  let index = 0
+  return async (
+    replyAuthor: User,
+    overridesOrCb?: Partial<AppBskyFeedPost.Record> | ReplyCb,
+    maybeReplyCb?: ReplyCb,
+  ) => {
+    let overrides: Partial<AppBskyFeedPost.Record> | undefined
+    let replyCb: ReplyCb | undefined
+    if (overridesOrCb && typeof overridesOrCb === 'function') {
+      replyCb = overridesOrCb
+    } else {
+      overrides = overridesOrCb
+      replyCb = maybeReplyCb
+    }
+
+    const breadcrumbs = prevBreadcrumbs
+      ? `${prevBreadcrumbs}.${index++}`
+      : `${index++}`
+    const text = breadcrumbs
+    const reply = await sc.reply(
+      replyAuthor.did,
+      root,
+      parent,
+      text,
+      undefined,
+      undefined,
+      overrides,
+    )
+    posts[breadcrumbs] = reply
+    // Await for this post to be processed before replying to it.
+    replyCb && (await sc.network.processAll())
+    await replyCb?.(rootReplyFnBuilder(sc, root, reply.ref, breadcrumbs, posts))
+  }
+}
+
+const createThread = async <T extends TestNetworkNoAppView>(
+  sc: SeedClient<T>,
+  rootAuthor: User,
+  overridesOrCb?: Partial<AppBskyFeedPost.Record> | ReplyCb,
+  maybeReplyCb?: ReplyCb,
+) => {
+  let overrides: Partial<AppBskyFeedPost.Record> | undefined
+  let replyCb: ReplyCb | undefined
+  if (overridesOrCb && typeof overridesOrCb === 'function') {
+    replyCb = overridesOrCb
+  } else {
+    overrides = overridesOrCb
+    replyCb = maybeReplyCb
+  }
+
+  const replies: Record<string, Awaited<ReturnType<SeedClient['reply']>>> = {}
+  const breadcrumbs = ''
+  const text = 'root'
+  const root = await sc.post(
+    rootAuthor.did,
+    text,
+    undefined,
+    undefined,
+    undefined,
+    overrides,
+  )
+  // Await for this post to be processed before replying to it.
+  replyCb && (await sc.network.processAll())
+  await replyCb?.(
+    rootReplyFnBuilder(sc, root.ref, root.ref, breadcrumbs, replies),
+  )
+  return { root, replies }
+}
+
+export async function simple(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+  prefix = 'simple',
+) {
+  const users = await createUsers(sc, prefix, [
+    'op',
+    'alice',
+    'bob',
+    'carol',
+  ] as const)
+  const { op, alice, bob, carol } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(op, async (r) => {
+      await r(op)
+    })
+    await r(alice)
+    await r(bob, async (r) => {
+      await r(alice)
+    })
+    await r(carol)
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function long(sc: SeedClient<TestNetwork | TestNetworkNoAppView>) {
+  const users = await createUsers(sc, 'long', [
+    'op',
+    'alice',
+    'bob',
+    'carol',
+    'dan',
+  ] as const)
+  const { op, alice, bob, carol, dan } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(op, async (r) => {
+      await r(op, async (r) => {
+        await r(op, async (r) => {
+          await r(op, async (r) => {
+            await r(op)
+          })
+        })
+        await r(op)
+      })
+    })
+
+    await r(alice)
+    await r(bob)
+    await r(carol)
+
+    await r(op, async (r) => {
+      await r(op, async (r) => {
+        await r(alice, async (r) => {
+          await r(op, async (r) => {
+            await r(op)
+          })
+        })
+      })
+    })
+
+    await r(alice)
+    await r(bob)
+    await r(carol)
+  })
+
+  await sc.like(op.did, r['5'].ref)
+  await sc.like(bob.did, r['5'].ref)
+  await sc.like(carol.did, r['5'].ref)
+  await sc.like(dan.did, r['5'].ref)
+
+  await sc.like(op.did, r['6'].ref)
+  await sc.like(alice.did, r['6'].ref)
+  await sc.like(carol.did, r['6'].ref)
+
+  await sc.like(op.did, r['7'].ref)
+  await sc.like(bob.did, r['7'].ref)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function deep(sc: SeedClient<TestNetwork | TestNetworkNoAppView>) {
+  const users = await createUsers(sc, 'deep', ['op'] as const)
+  const { op } = users
+
+  let counter = 0
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    const recursiveReply = async (rFn: ReplyFn) => {
+      if (counter < 18) {
+        counter++
+        await rFn(op, async (r) => recursiveReply(r))
+      }
+    }
+    await recursiveReply(r)
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function branchingFactor(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'bf', ['op', 'bob'] as const)
+  const { op, bob } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(bob, async (r) => {
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+    })
+    await r(bob, async (r) => {
+      await r(bob, async (r) => {
+        // This is the only case in this seed where a reply has 1 reply instead of 4,
+        // to have cases of different lengths in the same tree.
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+    })
+    await r(bob, async (r) => {
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+    })
+    await r(bob, async (r) => {
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        // This is the only case in this seed where a reply has 5 replies instead of 4,
+        // to have cases of different lengths in the same tree.
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+      await r(bob, async (r) => {
+        await r(bob)
+        await r(bob)
+        await r(bob)
+        await r(bob)
+      })
+    })
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function annotateMoreReplies(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'mr', ['op', 'alice'] as const)
+  const { op, alice } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(alice, async (r) => {
+      await r(alice, async (r) => {
+        await r(alice, async (r) => {
+          await r(alice, async (r) => {
+            // more replies... (below = 4)
+            await r(alice, async (r) => {
+              await r(alice)
+            })
+            await r(alice)
+            await r(alice, async (r) => {
+              await r(alice, async (r) => {
+                await r(alice)
+              })
+            })
+            await r(alice)
+            await r(alice)
+          })
+        })
+      })
+      await r(alice, async (r) => {
+        await r(alice, async (r) => {
+          await r(alice)
+        })
+      })
+    })
+    await r(alice, async (r) => {
+      await r(alice, async (r) => {
+        await r(alice)
+        await r(alice)
+        // more replies... (branchingFactor = 2)
+        await r(alice)
+        await r(alice)
+        await r(alice)
+      })
+      await r(alice, async (r) => {
+        await r(alice)
+        await r(alice)
+      })
+      // more replies... (branchingFactor = 2)
+      await r(alice)
+    })
+    await r(alice) // anchor reply not limited by branchingFactor
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function annotateOP(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'op', ['op', 'alice', 'bob'] as const)
+  const { op, alice, bob } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(op, async (r) => {
+      await r(op, async (r) => {
+        await r(op)
+      })
+    })
+    await r(alice, async (r) => {
+      await r(alice)
+    })
+    await r(op, async (r) => {
+      await r(bob, async (r) => {
+        await r(op)
+      })
+    })
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function sort(sc: SeedClient<TestNetwork | TestNetworkNoAppView>) {
+  const users = await createUsers(sc, 'sort', [
+    'op',
+    'alice',
+    'bob',
+    'carol',
+  ] as const)
+  const { op, alice, bob, carol } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    // 0 likes
+    await r(alice, async (r) => {
+      await r(carol) // 0 likes
+      await r(alice) // 2 likes
+      await r(bob) // 1 like
+    })
+    // 3 likes
+    await r(carol, async (r) => {
+      await r(bob) // 1 like
+      await r(carol) // 2 likes
+      await r(alice) // 0 likes
+    })
+    // 2 likes
+    await r(bob, async (r) => {
+      await r(bob) // 2 likes
+      await r(alice) // 1 like
+      await r(carol) // 0 likes
+    })
+  })
+
+  // likes depth 1
+  await sc.like(alice.did, r['2'].ref)
+  await sc.like(carol.did, r['2'].ref)
+  await sc.like(op.did, r['1'].ref) // op like
+  await sc.like(bob.did, r['1'].ref)
+  await sc.like(carol.did, r['1'].ref)
+
+  // likes depth 2
+  await sc.like(bob.did, r['0.1'].ref)
+  await sc.like(carol.did, r['0.1'].ref)
+  await sc.like(op.did, r['0.2'].ref) // op like
+  await sc.like(bob.did, r['1.1'].ref)
+  await sc.like(carol.did, r['1.1'].ref)
+  await sc.like(bob.did, r['1.0'].ref)
+  await sc.like(bob.did, r['2.0'].ref)
+  await sc.like(carol.did, r['2.0'].ref)
+  await sc.like(bob.did, r['2.1'].ref)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function bumpOpAndViewer(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'bumpOV', [
+    'op',
+    'viewer',
+    'alice',
+    'bob',
+    'carol',
+  ] as const)
+  const { op, viewer, alice, bob, carol } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    // 1 like
+    await r(alice, async (r) => {
+      await r(carol) // 0 likes
+      await r(alice) // 2 likes
+      await r(bob) // 1 like
+      await r(viewer) // 0 likes
+      await r(op) // 0 likes
+    })
+    // 3 likes
+    await r(carol, async (r) => {
+      await r(bob) // 1 like
+      await r(carol) // 2 likes
+      await r(op) // 0 likes
+      await r(viewer) // 1 like
+      await r(alice) // 0 likes
+    })
+    // 2 likes
+    await r(bob, async (r) => {
+      await r(viewer) // 0 likes
+      await r(bob) // 4 likes
+      await r(op) // 0 likes
+      await r(alice) // 1 like
+      await r(carol) // 1 like
+    })
+    // 0 likes
+    await r(op, async (r) => {
+      await r(viewer) // 0 likes
+      await r(bob) // 0 likes
+      await r(op) // 0 likes
+      await r(alice) // 0 likes
+      await r(carol) // 0 likes
+    })
+    // 0 likes
+    await r(viewer, async (r) => {
+      await r(bob) // 1 like
+      await r(carol) // 1 like
+      await r(op) // 0 likes
+      await r(viewer) // 0 likes
+      await r(alice) // 0 likes
+    })
+  })
+
+  // likes depth 1
+  await sc.like(alice.did, r['2'].ref)
+  await sc.like(carol.did, r['2'].ref)
+  await sc.like(viewer.did, r['0'].ref)
+  await sc.like(op.did, r['1'].ref) // op like
+  await sc.like(bob.did, r['1'].ref)
+  await sc.like(carol.did, r['1'].ref)
+
+  // likes depth 2
+  await sc.like(bob.did, r['0.1'].ref)
+  await sc.like(carol.did, r['0.1'].ref)
+  await sc.like(op.did, r['0.2'].ref) // op like
+  await sc.like(bob.did, r['1.1'].ref)
+  await sc.like(carol.did, r['1.1'].ref)
+  await sc.like(bob.did, r['1.0'].ref)
+  await sc.like(alice.did, r['2.1'].ref)
+  await sc.like(bob.did, r['2.1'].ref)
+  await sc.like(carol.did, r['2.1'].ref)
+  await sc.like(viewer.did, r['2.1'].ref)
+  await sc.like(bob.did, r['1.3'].ref)
+  await sc.like(bob.did, r['2.3'].ref)
+  await sc.like(viewer.did, r['2.4'].ref)
+  await sc.like(viewer.did, r['4.0'].ref)
+  await sc.like(alice.did, r['4.1'].ref)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function bumpGroupSorting(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'bumpGS', [
+    'op',
+    'viewer',
+    'alice',
+  ] as const)
+  const { op, viewer, alice } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(viewer)
+    await r(op)
+    await r(alice)
+    await r(op)
+    await r(viewer)
+    await r(op)
+    await r(alice)
+    await r(viewer)
+  })
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function bumpFollows(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'bumpF', [
+    'op',
+    'viewerF',
+    'viewerNoF',
+    'alice',
+    'bob',
+    'carol',
+  ] as const)
+
+  const { op, viewerF, viewerNoF, alice, bob, carol } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(alice)
+    await r(bob)
+    await r(carol)
+    await r(op)
+    await r(viewerF)
+    await r(viewerNoF)
+  })
+
+  await sc.follow(viewerF.did, alice.did)
+  await sc.follow(viewerF.did, bob.did)
+  // Does not follow carol.
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function blockDeletionAuth(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'bda', [
+    'op',
+    'opBlocked',
+    'alice',
+    'auth',
+    'blocker',
+    'blocked',
+  ] as const)
+
+  const { op, opBlocked, alice, auth, blocker, blocked } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    // 1p block, hidden for `blocked`.
+    await r(blocker, async (r) => {
+      await r(alice)
+    })
+
+    // 3p block, hidden for all.
+    await r(opBlocked, async (r) => {
+      await r(op)
+      await r(alice)
+    })
+
+    // Deleted, hidden for all.
+    await r(alice, async (r) => {
+      await r(alice)
+    })
+
+    // User configured to only be seend by authenticated users.
+    // Requires the test sets a `!no-unauthenticated` label for this user.
+    await r(auth, async (r) => {
+      // Another auth-only to show that the parent chain is preserved in the thread.
+      await r(auth, async (r) => {
+        await r(alice)
+      })
+    })
+  })
+
+  await sc.deletePost(alice.did, r['2'].ref.uri)
+  await sc.block(blocker.did, blocked.did)
+  await sc.block(op.did, opBlocked.did)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function mutes(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'mutes', [
+    'op',
+    'opMuted',
+    'alice',
+    'muted',
+    'muter',
+  ] as const)
+
+  const { op, opMuted, alice, muted, muter } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    await r(opMuted, async (r) => {
+      await r(alice)
+      await r(muted)
+    })
+
+    await r(muted, async (r) => {
+      await r(opMuted)
+      await r(alice)
+    })
+  })
+
+  await sc.mute(op.did, opMuted.did)
+  await sc.mute(muter.did, muted.did)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}
+
+export async function threadgated(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  const users = await createUsers(sc, 'tg', [
+    'op',
+    'opMuted',
+    'viewer',
+    'alice',
+    'bob',
+  ] as const)
+
+  const { op, opMuted, alice, bob } = users
+
+  const { root, replies: r } = await createThread(sc, op, async (r) => {
+    // Muted moves down below threadgated.
+    await r(opMuted)
+
+    // Threadgated moves down.
+    await r(alice, async (r) => {
+      await r(alice)
+      await r(bob)
+      await r(op) // OP moves up.
+    })
+
+    await r(bob, async (r) => {
+      await r(alice)
+      await r(bob) // Threadgated is omitted if fetched from the root.
+      await r(op) // OP moves down.
+    })
+  })
+
+  await sc.agent.app.bsky.feed.threadgate.create(
+    {
+      repo: op.did,
+      rkey: root.ref.uri.rkey,
+    },
+    {
+      post: root.ref.uriStr,
+      createdAt: new Date().toISOString(),
+      hiddenReplies: [r['1'].ref.uriStr, r['2.1'].ref.uriStr],
+    },
+    sc.getHeaders(op.did),
+  )
+
+  // Just throw a mute there to test the prioritization between muted and threadgated.
+  await sc.mute(op.did, opMuted.did)
+
+  return {
+    seedClient: sc,
+    users,
+    root,
+    r,
+  }
+}