@atproto/bsky 0.0.11 → 0.0.12

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

@@ -0,0 +1,100 @@
+import { TestNetwork, SeedClient } 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_action',
+    })
+    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 action for a repo.', async () => {
+    const result = await agent.api.com.atproto.admin.getModerationAction(
+      { id: 1 },
+      { headers: { authorization: network.pds.adminAuth() } },
+    )
+    expect(forSnapshot(result.data)).toMatchSnapshot()
+  })
+
+  it('gets moderation action for a record.', async () => {
+    const result = await agent.api.com.atproto.admin.getModerationAction(
+      { id: 2 },
+      { headers: { authorization: network.pds.adminAuth() } },
+    )
+    expect(forSnapshot(result.data)).toMatchSnapshot()
+  })
+
+  it('fails when moderation action does not exist.', async () => {
+    const promise = agent.api.com.atproto.admin.getModerationAction(
+      { id: 100 },
+      { headers: { authorization: network.pds.adminAuth() } },
+    )
+    await expect(promise).rejects.toThrow('Action not found')
+  })
+})

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

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,332 @@
+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)
+  })
+})