@atproto/bsky 0.0.15 → 0.0.17

package/tests/admin/get-moderation-actions.test.ts

@@ -1,164 +0,0 @@
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import AtpAgent from '@atproto/api'
-import {
-  ACKNOWLEDGE,
-  FLAG,
-  TAKEDOWN,
-} from '@atproto/api/src/client/types/com/atproto/admin/defs'
-import {
-  REASONOTHER,
-  REASONSPAM,
-} from '../../src/lexicon/types/com/atproto/moderation/defs'
-import { forSnapshot, paginateAll } from '../_util'
-import basicSeed from '../seeds/basic'
-
-describe('admin get moderation actions view', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'views_admin_get_moderation_actions',
-    })
-    agent = network.pds.getClient()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  beforeAll(async () => {
-    const oneIn = (n) => (_, i) => i % n === 0
-    const getAction = (i) => [FLAG, ACKNOWLEDGE, TAKEDOWN][i % 3]
-    const posts = Object.values(sc.posts)
-      .flatMap((x) => x)
-      .filter(oneIn(2))
-    const dids = Object.values(sc.dids).filter(oneIn(2))
-    // Take actions on records
-    const recordActions: Awaited<ReturnType<typeof sc.takeModerationAction>>[] =
-      []
-    for (let i = 0; i < posts.length; ++i) {
-      const post = posts[i]
-      recordActions.push(
-        await sc.takeModerationAction({
-          action: getAction(i),
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: post.ref.uriStr,
-            cid: post.ref.cidStr,
-          },
-        }),
-      )
-    }
-    // Reverse an action
-    await sc.reverseModerationAction({
-      id: recordActions[0].id,
-    })
-    // Take actions on repos
-    const repoActions: Awaited<ReturnType<typeof sc.takeModerationAction>>[] =
-      []
-    for (let i = 0; i < dids.length; ++i) {
-      const did = dids[i]
-      repoActions.push(
-        await sc.takeModerationAction({
-          action: getAction(i),
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did,
-          },
-        }),
-      )
-    }
-    // Back some of the actions with a report, possibly resolved
-    const someRecordActions = recordActions.filter(oneIn(2))
-    for (let i = 0; i < someRecordActions.length; ++i) {
-      const action = someRecordActions[i]
-      const ab = oneIn(2)(action, i)
-      const report = await sc.createReport({
-        reportedBy: ab ? sc.dids.carol : sc.dids.alice,
-        reasonType: ab ? REASONSPAM : REASONOTHER,
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: action.subject.uri,
-          cid: action.subject.cid,
-        },
-      })
-      if (ab) {
-        await sc.resolveReports({
-          actionId: action.id,
-          reportIds: [report.id],
-        })
-      }
-    }
-    const someRepoActions = repoActions.filter(oneIn(2))
-    for (let i = 0; i < someRepoActions.length; ++i) {
-      const action = someRepoActions[i]
-      const ab = oneIn(2)(action, i)
-      const report = await sc.createReport({
-        reportedBy: ab ? sc.dids.carol : sc.dids.alice,
-        reasonType: ab ? REASONSPAM : REASONOTHER,
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: action.subject.did,
-        },
-      })
-      if (ab) {
-        await sc.resolveReports({
-          actionId: action.id,
-          reportIds: [report.id],
-        })
-      }
-    }
-  })
-
-  it('gets all moderation actions.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationActions(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.actions)).toMatchSnapshot()
-  })
-
-  it('gets all moderation actions for a repo.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationActions(
-      { subject: Object.values(sc.dids)[0] },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.actions)).toMatchSnapshot()
-  })
-
-  it('gets all moderation actions for a record.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationActions(
-      { subject: Object.values(sc.posts)[0][0].ref.uriStr },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.actions)).toMatchSnapshot()
-  })
-
-  it('paginates.', async () => {
-    const results = (results) => results.flatMap((res) => res.actions)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.com.atproto.admin.getModerationActions(
-        { cursor, limit: 3 },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator)
-    paginatedAll.forEach((res) =>
-      expect(res.actions.length).toBeLessThanOrEqual(3),
-    )
-
-    const full = await agent.api.com.atproto.admin.getModerationActions(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-
-    expect(full.data.actions.length).toEqual(6)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-})

package/tests/admin/get-moderation-report.test.ts

@@ -1,100 +0,0 @@
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import AtpAgent from '@atproto/api'
-import {
-  FLAG,
-  TAKEDOWN,
-} from '@atproto/api/src/client/types/com/atproto/admin/defs'
-import {
-  REASONOTHER,
-  REASONSPAM,
-} from '../../src/lexicon/types/com/atproto/moderation/defs'
-import { forSnapshot } from '../_util'
-import basicSeed from '../seeds/basic'
-
-describe('admin get moderation action view', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'views_admin_get_moderation_report',
-    })
-    agent = network.pds.getClient()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  beforeAll(async () => {
-    const reportRepo = await sc.createReport({
-      reportedBy: sc.dids.bob,
-      reasonType: REASONSPAM,
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      },
-    })
-    const reportRecord = await sc.createReport({
-      reportedBy: sc.dids.carol,
-      reasonType: REASONOTHER,
-      reason: 'defamation',
-      subject: {
-        $type: 'com.atproto.repo.strongRef',
-        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
-        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
-      },
-    })
-    const flagRepo = await sc.takeModerationAction({
-      action: FLAG,
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      },
-    })
-    const takedownRecord = await sc.takeModerationAction({
-      action: TAKEDOWN,
-      subject: {
-        $type: 'com.atproto.repo.strongRef',
-        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
-        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
-      },
-    })
-    await sc.resolveReports({
-      actionId: flagRepo.id,
-      reportIds: [reportRepo.id, reportRecord.id],
-    })
-    await sc.resolveReports({
-      actionId: takedownRecord.id,
-      reportIds: [reportRecord.id],
-    })
-    await sc.reverseModerationAction({ id: flagRepo.id })
-  })
-
-  it('gets moderation report for a repo.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReport(
-      { id: 1 },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data)).toMatchSnapshot()
-  })
-
-  it('gets moderation report for a record.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReport(
-      { id: 2 },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data)).toMatchSnapshot()
-  })
-
-  it('fails when moderation report does not exist.', async () => {
-    const promise = agent.api.com.atproto.admin.getModerationReport(
-      { id: 100 },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    await expect(promise).rejects.toThrow('Report not found')
-  })
-})

package/tests/admin/get-moderation-reports.test.ts

@@ -1,332 +0,0 @@
-import { SeedClient, TestNetwork } from '@atproto/dev-env'
-import AtpAgent from '@atproto/api'
-import {
-  ACKNOWLEDGE,
-  FLAG,
-  TAKEDOWN,
-} from '@atproto/api/src/client/types/com/atproto/admin/defs'
-import {
-  REASONOTHER,
-  REASONSPAM,
-} from '../../src/lexicon/types/com/atproto/moderation/defs'
-import { forSnapshot, paginateAll } from '../_util'
-import basicSeed from '../seeds/basic'
-
-describe('admin get moderation reports view', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'views_admin_get_moderation_reports',
-    })
-    agent = network.pds.getClient()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-  })
-
-  afterAll(async () => {
-    await network.close()
-  })
-
-  beforeAll(async () => {
-    const oneIn = (n) => (_, i) => i % n === 0
-    const getAction = (i) => [FLAG, ACKNOWLEDGE, TAKEDOWN][i % 3]
-    const getReasonType = (i) => [REASONOTHER, REASONSPAM][i % 2]
-    const getReportedByDid = (i) => [sc.dids.alice, sc.dids.carol][i % 2]
-    const posts = Object.values(sc.posts)
-      .flatMap((x) => x)
-      .filter(oneIn(2))
-    const dids = Object.values(sc.dids).filter(oneIn(2))
-    const recordReports: Awaited<ReturnType<typeof sc.createReport>>[] = []
-    for (let i = 0; i < posts.length; ++i) {
-      const post = posts[i]
-      recordReports.push(
-        await sc.createReport({
-          reasonType: getReasonType(i),
-          reportedBy: getReportedByDid(i),
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: post.ref.uriStr,
-            cid: post.ref.cidStr,
-          },
-        }),
-      )
-    }
-    const repoReports: Awaited<ReturnType<typeof sc.createReport>>[] = []
-    for (let i = 0; i < dids.length; ++i) {
-      const did = dids[i]
-      repoReports.push(
-        await sc.createReport({
-          reasonType: getReasonType(i),
-          reportedBy: getReportedByDid(i),
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did,
-          },
-        }),
-      )
-    }
-    for (let i = 0; i < recordReports.length; ++i) {
-      const report = recordReports[i]
-      const ab = oneIn(2)(report, i)
-      const action = await sc.takeModerationAction({
-        action: getAction(i),
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: report.subject.uri,
-          cid: report.subject.cid,
-        },
-        createdBy: `did:example:admin${i}`,
-      })
-      if (ab) {
-        await sc.resolveReports({
-          actionId: action.id,
-          reportIds: [report.id],
-        })
-      } else {
-        await sc.reverseModerationAction({
-          id: action.id,
-        })
-      }
-    }
-    for (let i = 0; i < repoReports.length; ++i) {
-      const report = repoReports[i]
-      const ab = oneIn(2)(report, i)
-      const action = await sc.takeModerationAction({
-        action: getAction(i),
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: report.subject.did,
-        },
-      })
-      if (ab) {
-        await sc.resolveReports({
-          actionId: action.id,
-          reportIds: [report.id],
-        })
-      } else {
-        await sc.reverseModerationAction({
-          id: action.id,
-        })
-      }
-    }
-  })
-
-  it('ignores subjects when specified.', async () => {
-    // Get all reports and then make another request with a filter to ignore some subject dids
-    // and assert that the reports for those subject dids are ignored in the result set
-    const getDids = (reportsResponse) =>
-      reportsResponse.data.reports
-        .map((report) => report.subject.did)
-        // Not all reports contain a did so we're discarding the undefined values in the mapped array
-        .filter(Boolean)
-
-    const allReports = await agent.api.com.atproto.admin.getModerationReports(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-
-    const ignoreSubjects = getDids(allReports).slice(0, 2)
-
-    const filteredReportsByDid =
-      await agent.api.com.atproto.admin.getModerationReports(
-        { ignoreSubjects },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-
-    // Validate that when ignored by DID, all reports for that DID is ignored
-    getDids(filteredReportsByDid).forEach((resultDid) =>
-      expect(ignoreSubjects).not.toContain(resultDid),
-    )
-
-    const ignoredAtUriSubjects: string[] = [
-      `${
-        allReports.data.reports.find(({ subject }) => !!subject.uri)?.subject
-          ?.uri
-      }`,
-    ]
-    const filteredReportsByAtUri =
-      await agent.api.com.atproto.admin.getModerationReports(
-        {
-          ignoreSubjects: ignoredAtUriSubjects,
-        },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-
-    // Validate that when ignored by at uri, only the reports for that at uri is ignored
-    expect(filteredReportsByAtUri.data.reports.length).toEqual(
-      allReports.data.reports.length - 1,
-    )
-    expect(
-      filteredReportsByAtUri.data.reports
-        .map(({ subject }) => subject.uri)
-        .filter(Boolean),
-    ).not.toContain(ignoredAtUriSubjects[0])
-  })
-
-  it('gets all moderation reports.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReports(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.reports)).toMatchSnapshot()
-  })
-
-  it('gets all moderation reports for a repo.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReports(
-      { subject: Object.values(sc.dids)[0] },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.reports)).toMatchSnapshot()
-  })
-
-  it('gets all moderation reports for a record.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReports(
-      { subject: Object.values(sc.posts)[0][0].ref.uriStr },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(result.data.reports)).toMatchSnapshot()
-  })
-
-  it('gets all resolved/unresolved moderation reports.', async () => {
-    const resolved = await agent.api.com.atproto.admin.getModerationReports(
-      { resolved: true },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(resolved.data.reports)).toMatchSnapshot()
-    const unresolved = await agent.api.com.atproto.admin.getModerationReports(
-      { resolved: false },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(forSnapshot(unresolved.data.reports)).toMatchSnapshot()
-  })
-
-  it('allows reverting the order of reports.', async () => {
-    const [
-      {
-        data: { reports: reverseList },
-      },
-      {
-        data: { reports: defaultList },
-      },
-    ] = await Promise.all([
-      agent.api.com.atproto.admin.getModerationReports(
-        { reverse: true },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-      agent.api.com.atproto.admin.getModerationReports(
-        {},
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-    ])
-
-    expect(defaultList[0].id).toEqual(reverseList[reverseList.length - 1].id)
-    expect(defaultList[defaultList.length - 1].id).toEqual(reverseList[0].id)
-  })
-
-  it('gets all moderation reports by active resolution action type.', async () => {
-    const reportsWithTakedown =
-      await agent.api.com.atproto.admin.getModerationReports(
-        { actionType: TAKEDOWN },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-    expect(forSnapshot(reportsWithTakedown.data.reports)).toMatchSnapshot()
-  })
-
-  it('gets all moderation reports actioned by a certain moderator.', async () => {
-    const adminDidOne = 'did:example:admin0'
-    const adminDidTwo = 'did:example:admin2'
-    const [actionedByAdminOne, actionedByAdminTwo] = await Promise.all([
-      agent.api.com.atproto.admin.getModerationReports(
-        { actionedBy: adminDidOne },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-      agent.api.com.atproto.admin.getModerationReports(
-        { actionedBy: adminDidTwo },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-    ])
-    const [fullReportOne, fullReportTwo] = await Promise.all([
-      agent.api.com.atproto.admin.getModerationReport(
-        { id: actionedByAdminOne.data.reports[0].id },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-      agent.api.com.atproto.admin.getModerationReport(
-        { id: actionedByAdminTwo.data.reports[0].id },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-    ])
-
-    expect(forSnapshot(actionedByAdminOne.data.reports)).toMatchSnapshot()
-    expect(fullReportOne.data.resolvedByActions[0].createdBy).toEqual(
-      adminDidOne,
-    )
-    expect(forSnapshot(actionedByAdminTwo.data.reports)).toMatchSnapshot()
-    expect(fullReportTwo.data.resolvedByActions[0].createdBy).toEqual(
-      adminDidTwo,
-    )
-  })
-
-  it('paginates.', async () => {
-    const results = (results) => results.flatMap((res) => res.reports)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.com.atproto.admin.getModerationReports(
-        { cursor, limit: 3 },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator)
-    paginatedAll.forEach((res) =>
-      expect(res.reports.length).toBeLessThanOrEqual(3),
-    )
-
-    const full = await agent.api.com.atproto.admin.getModerationReports(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-
-    expect(full.data.reports.length).toEqual(6)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-
-  it('paginates reverted list of reports.', async () => {
-    const paginator =
-      (reverse = false) =>
-      async (cursor?: string) => {
-        const res = await agent.api.com.atproto.admin.getModerationReports(
-          { cursor, limit: 3, reverse },
-          { headers: network.pds.adminAuthHeaders() },
-        )
-        return res.data
-      }
-
-    const [reverseResponse, defaultResponse] = await Promise.all([
-      paginateAll(paginator(true)),
-      paginateAll(paginator()),
-    ])
-
-    const reverseList = reverseResponse.flatMap((res) => res.reports)
-    const defaultList = defaultResponse.flatMap((res) => res.reports)
-
-    expect(defaultList[0].id).toEqual(reverseList[reverseList.length - 1].id)
-    expect(defaultList[defaultList.length - 1].id).toEqual(reverseList[0].id)
-  })
-
-  it('filters reports by reporter DID.', async () => {
-    const result = await agent.api.com.atproto.admin.getModerationReports(
-      { reporters: [sc.dids.alice] },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-
-    const reporterDidsFromReports = [
-      ...new Set(result.data.reports.map(({ reportedBy }) => reportedBy)),
-    ]
-
-    expect(reporterDidsFromReports.length).toEqual(1)
-    expect(reporterDidsFromReports[0]).toEqual(sc.dids.alice)
-  })
-})