@atproto/bsky 0.0.251 → 0.0.254

package/tests/views/get-suggested-starter-packs.test.ts

@@ -1,137 +0,0 @@
-import { once } from 'node:events'
-import { Server, createServer } from 'node:http'
-import { AddressInfo } from 'node:net'
-import express, { Application } from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import {
-  AppBskyUnspeccedGetSuggestedStarterPacksSkeleton,
-  AtpAgent,
-  ids,
-} from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import {
-  StarterPacks,
-  Users,
-  starterPacksSeed,
-} from '../seed/get-suggested-starter-packs.js'
-
-describe('getSuggestedStarterPacks', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let users: Users
-  let mockServer: MockServer
-  let starterpacks: StarterPacks
-
-  beforeAll(async () => {
-    mockServer = new MockServer()
-    await mockServer.listen()
-
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_tests_get_suggested_starter_packs',
-      bsky: {
-        topicsUrl: mockServer.url,
-        topicsApiKey: 'test',
-      },
-    })
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-
-    const result = await starterPacksSeed(sc)
-    users = result.users
-    starterpacks = result.starterpacks
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-  afterAll(async () => mockServer?.stop())
-
-  describe(`basic handling`, () => {
-    beforeAll(() => {
-      const pack = Object.values(starterpacks[users.creator.did])[0]
-      mockServer.mockedStarterPackUris.set('a', pack.ref.uriStr)
-    })
-
-    afterAll(() => {
-      mockServer.mockedStarterPackUris.delete('a')
-    })
-
-    it(`returns pack for non-blocking user`, async () => {
-      const { data } = await agent.app.bsky.unspecced.getSuggestedStarterPacks(
-        undefined,
-        {
-          headers: await network.serviceHeaders(
-            users.viewer.did,
-            ids.AppBskyUnspeccedGetSuggestedStarterPacks,
-          ),
-        },
-      )
-      const sp = data.starterPacks[0]
-      expect(sp).toBeDefined()
-    })
-
-    it(`does not return pack if creator blocked by viewer`, async () => {
-      const { data } = await agent.app.bsky.unspecced.getSuggestedStarterPacks(
-        undefined,
-        {
-          headers: await network.serviceHeaders(
-            users.viewerBlocker.did,
-            ids.AppBskyUnspeccedGetSuggestedStarterPacks,
-          ),
-        },
-      )
-      const sp = data.starterPacks[0]
-      expect(sp).not.toBeDefined()
-    })
-  })
-})
-
-class MockServer {
-  app: Application
-  server: Server
-  terminator: httpTerminator.HttpTerminator
-
-  mockedStarterPackUris = new Map<
-    string,
-    AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.OutputSchema['starterPacks'][0]
-  >()
-
-  constructor() {
-    this.app = this.createApp()
-    this.server = createServer(this.app)
-    this.terminator = httpTerminator.createHttpTerminator({
-      server: this.server,
-    })
-  }
-
-  async listen(port?: number) {
-    this.server.listen(port)
-    await once(this.server, 'listening')
-  }
-
-  async stop() {
-    await this.terminator.terminate()
-  }
-
-  get url() {
-    const address = this.server.address() as AddressInfo
-    return `http://localhost:${address.port}`
-  }
-
-  private createApp() {
-    const app = express()
-    app.get(
-      '/xrpc/app.bsky.unspecced.getSuggestedStarterPacksSkeleton',
-      (req, res) => {
-        const skeleton: AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.OutputSchema =
-          {
-            starterPacks: Array.from(this.mockedStarterPackUris.values()),
-          }
-        return res.json(skeleton)
-      },
-    )
-    return app
-  }
-}

package/tests/views/get-trends.test.ts

@@ -1,141 +0,0 @@
-import assert from 'node:assert'
-import { once } from 'node:events'
-import { Server, createServer } from 'node:http'
-import { AddressInfo } from 'node:net'
-import express, { Application } from 'express'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AppBskyUnspeccedGetTrendsSkeleton, AtpAgent, ids } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import { Users, trendsSeed } from '../seed/get-trends.js'
-
-describe('getTrends', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let users: Users
-  let mockTrendServer: MockTrendsServer
-
-  beforeAll(async () => {
-    mockTrendServer = new MockTrendsServer()
-    await mockTrendServer.listen()
-
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_tests_get_trends_test_b',
-      bsky: {
-        topicsUrl: mockTrendServer.url,
-        topicsApiKey: 'test',
-      },
-    })
-    agent = network.bsky.getAgent()
-    sc = network.getSeedClient()
-
-    const result = await trendsSeed(sc)
-    users = result.users
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-  afterAll(async () => mockTrendServer?.stop())
-
-  describe(`basic handling`, () => {
-    beforeAll(() => {
-      mockTrendServer.mockedTrendSkeletons.set('a', {
-        topic: 'a',
-        displayName: 'A',
-        link: '/test',
-        startedAt: new Date().toISOString(),
-        postCount: 3,
-        dids: [users.posterA.did, users.posterB.did, users.posterC.did],
-      })
-    })
-
-    afterAll(() => {
-      mockTrendServer.mockedTrendSkeletons.delete('a')
-    })
-
-    it(`returns all users for non-blocked user`, async () => {
-      const { data } = await agent.app.bsky.unspecced.getTrends(undefined, {
-        headers: await network.serviceHeaders(
-          users.viewer.did,
-          ids.AppBskyUnspeccedGetTrends,
-        ),
-      })
-      const trendA = data.trends.find((t) => t.topic === 'a')
-
-      assert(trendA)
-
-      expect(trendA.actors.map((a) => a.did)).toEqual([
-        users.posterA.did,
-        users.posterB.did,
-        users.posterC.did,
-      ])
-    })
-
-    it(`does not return user blocked by viewer`, async () => {
-      const { data } = await agent.app.bsky.unspecced.getTrends(undefined, {
-        headers: await network.serviceHeaders(
-          users.viewerBlocker.did,
-          ids.AppBskyUnspeccedGetTrends,
-        ),
-      })
-      const trendA = data.trends.find((t) => t.topic === 'a')
-
-      assert(trendA)
-
-      expect(trendA.actors.map((a) => a.did)).toEqual([
-        users.posterA.did,
-        users.posterB.did,
-      ])
-    })
-  })
-})
-
-class MockTrendsServer {
-  app: Application
-  server: Server
-  terminator: httpTerminator.HttpTerminator
-
-  mockedTrendSkeletons = new Map<
-    string,
-    AppBskyUnspeccedGetTrendsSkeleton.OutputSchema['trends'][0]
-  >()
-
-  constructor() {
-    this.app = this.createApp()
-    this.server = createServer(this.app)
-    this.terminator = httpTerminator.createHttpTerminator({
-      server: this.server,
-    })
-  }
-
-  async listen(port?: number) {
-    this.server.listen(port)
-    await once(this.server, 'listening')
-  }
-
-  async stop() {
-    await this.terminator.terminate()
-  }
-
-  async [Symbol.asyncDispose]() {
-    await this.stop()
-  }
-
-  get url() {
-    const address = this.server.address() as AddressInfo
-    return `http://localhost:${address.port}`
-  }
-
-  private createApp() {
-    const app = express()
-    app.get('/xrpc/app.bsky.unspecced.getTrendsSkeleton', (req, res) => {
-      const skeleton: AppBskyUnspeccedGetTrendsSkeleton.OutputSchema = {
-        trends: Array.from(this.mockedTrendSkeletons.values()),
-      }
-      return res.json(skeleton)
-    })
-    return app
-  }
-}

package/tests/views/internal-actor.test.ts

@@ -1,127 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AppBskyActorDefs, AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { knownFollowersSeed } from '../seed/known-followers.js'
-
-describe('internal actor views', () => {
-  let network: TestNetwork
-  let pdsAgent: AtpAgent
-  let seedClient: SeedClient
-
-  let dids: Record<string, DidString>
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_internal_actor',
-    })
-    pdsAgent = network.pds.getAgent()
-    seedClient = network.getSeedClient()
-
-    await knownFollowersSeed(seedClient)
-
-    dids = seedClient.dids
-
-    /*
-     * Mix of blocks and non, mirroring the known-followers test setup so the
-     * social proof results exercise block filtering too.
-     */
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.mix_view },
-      { createdAt: new Date().toISOString(), subject: dids.mix_fp_block_res },
-      seedClient.getHeaders(dids.mix_view),
-    )
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.mix_sub_1 },
-      { createdAt: new Date().toISOString(), subject: dids.mix_sp_block_res },
-      seedClient.getHeaders(dids.mix_sub_1),
-    )
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  describe('getProfiles', () => {
-    const getProfiles = async (
-      params: { dids: string[]; socialProof?: string[]; viewer?: string },
-      headers: Record<string, string> = network.bsky.adminAuthHeaders(),
-    ) => {
-      const search = new URLSearchParams()
-      params.dids.forEach((did) => search.append('dids', did))
-      params.socialProof?.forEach((did) => search.append('socialProof', did))
-      if (params.viewer) search.append('viewer', params.viewer)
-      const res = await fetch(
-        `${network.bsky.url}/xrpc/internal.bsky.actor.getProfiles?${search.toString()}`,
-        { headers },
-      )
-      return {
-        status: res.status,
-        body: (await res.json()) as {
-          profiles: AppBskyActorDefs.ProfileViewDetailed[]
-        },
-      }
-    }
-
-    it('requires role auth, rejecting standard user auth', async () => {
-      const userHeaders = await network.serviceHeaders(
-        dids.mix_view,
-        'internal.bsky.actor.getProfiles',
-      )
-      const { status } = await getProfiles(
-        { dids: [dids.mix_sub_1] },
-        userHeaders,
-      )
-      expect(status).toBe(401)
-    })
-
-    it('returns all profiles, with social proof only for the requested subset', async () => {
-      const { status, body } = await getProfiles({
-        dids: [dids.mix_sub_1, dids.mix_sub_2, dids.mix_sub_3],
-        socialProof: [dids.mix_sub_1],
-        viewer: dids.mix_view,
-      })
-      expect(status).toBe(200)
-      expect(body.profiles).toHaveLength(3)
-
-      const [sub_1, sub_2, sub_3] = body.profiles
-      expect(sub_1.viewer?.knownFollowers?.count).toBe(3)
-      expect(sub_1.viewer?.knownFollowers?.followers).toHaveLength(1)
-      expect(sub_2.viewer?.knownFollowers).toBeUndefined()
-      expect(sub_3.viewer?.knownFollowers).toBeUndefined()
-    })
-
-    it('ignores socialProof dids that are not in dids', async () => {
-      const { status, body } = await getProfiles({
-        dids: [dids.mix_sub_1],
-        socialProof: [dids.mix_sub_1, dids.mix_sub_2],
-        viewer: dids.mix_view,
-      })
-      expect(status).toBe(200)
-      expect(body.profiles).toHaveLength(1)
-      expect(body.profiles[0].did).toBe(dids.mix_sub_1)
-      expect(body.profiles[0].viewer?.knownFollowers?.count).toBe(3)
-    })
-
-    it('returns no social proof when socialProof is omitted', async () => {
-      const { status, body } = await getProfiles({
-        dids: [dids.mix_sub_1, dids.mix_sub_2],
-        viewer: dids.mix_view,
-      })
-      expect(status).toBe(200)
-      expect(body.profiles).toHaveLength(2)
-      for (const profile of body.profiles) {
-        expect(profile.viewer?.knownFollowers).toBeUndefined()
-      }
-    })
-
-    it('returns no viewer state when viewer is omitted', async () => {
-      const { status, body } = await getProfiles({
-        dids: [dids.mix_sub_1],
-        socialProof: [dids.mix_sub_1],
-      })
-      expect(status).toBe(200)
-      expect(body.profiles).toHaveLength(1)
-      expect(body.profiles[0].viewer).toBeUndefined()
-    })
-  })
-})

package/tests/views/known-followers.test.ts

@@ -1,193 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import { AtpAgent, ids } from '@atproto/api'
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-import { knownFollowersSeed } from '../seed/known-followers.js'
-
-describe('known followers (social proof)', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let pdsAgent: AtpAgent
-  let seedClient: SeedClient
-
-  let dids: Record<string, DidString>
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_known_followers',
-    })
-    agent = network.bsky.getAgent()
-    pdsAgent = network.pds.getAgent()
-    seedClient = network.getSeedClient()
-
-    await knownFollowersSeed(seedClient)
-
-    dids = seedClient.dids
-
-    /*
-     * First-party block
-     */
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.fp_block_view },
-      { createdAt: new Date().toISOString(), subject: dids.fp_block_res_1 },
-      seedClient.getHeaders(dids.fp_block_view),
-    )
-
-    /*
-     * Second-party block
-     */
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.sp_block_sub },
-      { createdAt: new Date().toISOString(), subject: dids.sp_block_res_1 },
-      seedClient.getHeaders(dids.sp_block_sub),
-    )
-
-    /*
-     * Mix of blocks and non
-     */
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.mix_view },
-      { createdAt: new Date().toISOString(), subject: dids.mix_fp_block_res },
-      seedClient.getHeaders(dids.mix_view),
-    )
-    await pdsAgent.api.app.bsky.graph.block.create(
-      { repo: dids.mix_sub_1 },
-      { createdAt: new Date().toISOString(), subject: dids.mix_sp_block_res },
-      seedClient.getHeaders(dids.mix_sub_1),
-    )
-  })
-
-  beforeEach(async () => network.processAll())
-  afterAll(async () => network?.close())
-
-  /*
-   * Note that this test arbitrarily uses `getFollows` bc atm it returns
-   * `ProfileViewBasic`. This method could be updated one day to return
-   * `knownFollowers`, in which case this test would begin failing.
-   */
-  it('basic profile views do not return knownFollowers', async () => {
-    const { data } = await agent.api.app.bsky.graph.getFollows(
-      { actor: dids.base_res_1 },
-      {
-        headers: await network.serviceHeaders(
-          dids.base_view,
-          ids.AppBskyGraphGetFollows,
-        ),
-      },
-    )
-    const follow = data.follows[0]
-
-    expect(follow.viewer?.knownFollowers).toBeFalsy()
-  })
-
-  it('getKnownFollowers: returns data', async () => {
-    const { data } = await agent.api.app.bsky.graph.getKnownFollowers(
-      { actor: dids.base_sub },
-      {
-        headers: await network.serviceHeaders(
-          dids.base_view,
-          ids.AppBskyGraphGetKnownFollowers,
-        ),
-      },
-    )
-
-    expect(data.subject.did).toBe(dids.base_sub)
-    expect(data.followers.length).toBe(1)
-    expect(data.followers[0].did).toBe(dids.base_res_1)
-  })
-
-  it('getProfile: returns knownFollowers', async () => {
-    const { data } = await agent.api.app.bsky.actor.getProfile(
-      { actor: dids.base_sub },
-      {
-        headers: await network.serviceHeaders(
-          dids.base_view,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-
-    const knownFollowers = data.viewer?.knownFollowers
-    expect(knownFollowers?.count).toBe(1)
-    expect(knownFollowers?.followers).toHaveLength(1)
-    expect(knownFollowers?.followers[0].did).toBe(dids.base_res_1)
-  })
-
-  it('getProfile: filters 1st-party blocks', async () => {
-    const { data } = await agent.api.app.bsky.actor.getProfile(
-      { actor: dids.fp_block_sub },
-      {
-        headers: await network.serviceHeaders(
-          dids.fp_block_view,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-
-    const knownFollowers = data.viewer?.knownFollowers
-    expect(knownFollowers?.count).toBe(1)
-    expect(knownFollowers?.followers).toHaveLength(0)
-  })
-
-  it('getProfile: filters second-party blocks', async () => {
-    const result = await agent.api.app.bsky.actor.getProfile(
-      { actor: dids.sp_block_sub },
-      {
-        headers: await network.serviceHeaders(
-          dids.sp_block_view,
-          ids.AppBskyActorGetProfile,
-        ),
-      },
-    )
-
-    const knownFollowers = result.data.viewer?.knownFollowers
-    expect(knownFollowers?.count).toBe(1)
-    expect(knownFollowers?.followers).toHaveLength(0)
-  })
-
-  it('getProfiles: filters second-party blocks', async () => {
-    const result = await agent.api.app.bsky.actor.getProfiles(
-      { actors: [dids.sp_block_sub] },
-      {
-        headers: await network.serviceHeaders(
-          dids.sp_block_view,
-          ids.AppBskyActorGetProfiles,
-        ),
-      },
-    )
-
-    expect(result.data.profiles).toHaveLength(1)
-    const profile = result.data.profiles[0]
-    const knownFollowers = profile.viewer?.knownFollowers
-    expect(knownFollowers?.count).toBe(1)
-    expect(knownFollowers?.followers).toHaveLength(0)
-  })
-
-  it('getProfiles: mix of results', async () => {
-    const result = await agent.api.app.bsky.actor.getProfiles(
-      { actors: [dids.mix_sub_1, dids.mix_sub_2, dids.mix_sub_3] },
-      {
-        headers: await network.serviceHeaders(
-          dids.mix_view,
-          ids.AppBskyActorGetProfiles,
-        ),
-      },
-    )
-
-    expect(result.data.profiles).toHaveLength(3)
-
-    const [sub_1, sub_2, sub_3] = result.data.profiles
-
-    const sub_1_kf = sub_1.viewer?.knownFollowers
-    expect(sub_1_kf?.count).toBe(3)
-    expect(sub_1_kf?.followers).toHaveLength(1)
-
-    const sub_2_kf = sub_2.viewer?.knownFollowers
-    expect(sub_2_kf?.count).toBe(3)
-    expect(sub_2_kf?.followers).toHaveLength(2)
-
-    const sub_3_kf = sub_3.viewer?.knownFollowers
-    expect(sub_3_kf?.count).toBe(3)
-    expect(sub_3_kf?.followers).toHaveLength(2)
-  })
-})