@atproto/ozone 0.2.8 → 0.2.11

package/tests/report-assignment.test.ts

@@ -1,517 +0,0 @@
-import AtpAgent, {
-  ComAtprotoModerationDefs,
-  ToolsOzoneReportAssignModerator,
-  ToolsOzoneReportGetAssignments,
-  ToolsOzoneReportListActivities,
-  ToolsOzoneReportUnassignModerator,
-} from '@atproto/api'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-
-describe('report-assignment', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  const assignReport = async (
-    input: ToolsOzoneReportAssignModerator.InputSchema,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.report.assignModerator(input, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneReportAssignModerator,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const unassignReport = async (
-    input: ToolsOzoneReportUnassignModerator.InputSchema,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.report.unassignModerator(input, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneReportUnassignModerator,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const getAssignments = async (
-    input: ToolsOzoneReportGetAssignments.QueryParams,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.report.getAssignments(input, {
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneReportGetAssignments,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const clearQueues = async () => {
-    await network.ozone.ctx.db.db.deleteFrom('report_queue').execute()
-  }
-  const clearAssignments = async () => {
-    await network.ozone.ctx.db.db.deleteFrom('moderator_assignment').execute()
-  }
-
-  const listActivities = async (
-    params: ToolsOzoneReportListActivities.QueryParams,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
-  ) => {
-    const { data } = await agent.tools.ozone.report.listActivities(params, {
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneReportListActivities,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const createReport = async (): Promise<number> => {
-    const event = await sc.createReport({
-      reasonType: ComAtprotoModerationDefs.REASONSPAM,
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.bob,
-      },
-      reportedBy: sc.dids.alice,
-    })
-    // Report rows are inserted asynchronously by the queue-router daemon —
-    // drain it before looking up the row.
-    await network.processAll()
-    const report = await network.ozone.ctx.db.db
-      .selectFrom('report')
-      .select('id')
-      .where('eventId', '=', event.id)
-      .executeTakeFirstOrThrow()
-    return report.id
-  }
-
-  const createQueue = async (name: string, reportTypes: string[]) => {
-    const { data } = await agent.tools.ozone.queue.createQueue(
-      {
-        name,
-        subjectTypes: ['account'],
-        reportTypes,
-      },
-      {
-        encoding: 'application/json',
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneQueueCreateQueue,
-          'admin',
-        ),
-      },
-    )
-    return data
-  }
-
-  let queueId: number
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'report_assignment',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-    await clearAssignments()
-    await clearQueues()
-
-    const queue = await createQueue('Report Queue', [
-      'com.atproto.moderation.defs#reasonSpam',
-    ])
-    queueId = queue.queue.id
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('can get assignment history', async () => {
-    const reportId = await createReport()
-    await assignReport({ reportId }, 'moderator')
-    const result = await getAssignments({ reportIds: [reportId] })
-    expect(result.assignments.length).toBe(1)
-  })
-
-  it('moderator can assign', async () => {
-    const reportId = await createReport()
-    const assignment = await assignReport({ reportId }, 'moderator')
-    expect(assignment.reportId).toBe(reportId)
-    expect(assignment.moderator?.did).toBe(network.ozone.moderatorAccnt.did)
-    expect(new Date(assignment.endAt!).getTime()).toBeGreaterThanOrEqual(
-      new Date().getTime(),
-    )
-  })
-
-  it('moderator can refresh assignment', async () => {
-    const reportId = await createReport()
-    const assignment1 = await assignReport({ reportId }, 'moderator')
-    const assignment2 = await assignReport({ reportId }, 'moderator')
-    expect(assignment2.moderator?.did).toBe(network.ozone.moderatorAccnt.did)
-    expect(new Date(assignment2.endAt!).getTime()).toBeGreaterThan(
-      new Date(assignment1.endAt!).getTime(),
-    )
-  })
-
-  it('moderator can assign then un-assign a report', async () => {
-    const reportId = await createReport()
-    await assignReport({ reportId }, 'moderator')
-    const assignment = await unassignReport({ reportId }, 'moderator')
-    expect(new Date(assignment.endAt!).getTime()).toBeLessThanOrEqual(
-      new Date().getTime(),
-    )
-  })
-
-  it('assignment can be exchanged', async () => {
-    const reportId = await createReport()
-    await assignReport({ reportId }, 'admin')
-    await unassignReport({ reportId }, 'moderator')
-    const assignment = await assignReport({ reportId }, 'moderator')
-    expect(assignment.reportId).toBe(reportId)
-    expect(assignment.moderator?.did).toBe(network.ozone.moderatorAccnt.did)
-    expect(new Date(assignment.endAt!).getTime()).toBeGreaterThanOrEqual(
-      new Date().getTime(),
-    )
-  })
-
-  it('invalid assignment throws error', async () => {
-    const reportId = 999999
-    await expect(assignReport({ reportId }, 'moderator')).rejects.toThrow(
-      'Invalid report',
-    )
-  })
-
-  it('invalid unassignment throws error', async () => {
-    const reportId = await createReport()
-    await expect(unassignReport({ reportId }, 'moderator')).rejects.toThrow(
-      'Report is not assigned',
-    )
-  })
-
-  describe('pagination', () => {
-    it('paginates assignments with limit', async () => {
-      await clearAssignments()
-      const r1 = await createReport()
-      const r2 = await createReport()
-      const r3 = await createReport()
-      await assignReport({ reportId: r1 }, 'admin')
-      await assignReport({ reportId: r2 }, 'admin')
-      await assignReport({ reportId: r3 }, 'admin')
-
-      const firstPage = await getAssignments({ limit: 2 })
-      expect(firstPage.assignments.length).toBe(2)
-      expect(firstPage.cursor).toBeDefined()
-    })
-
-    it('returns all results when limit exceeds total', async () => {
-      await clearAssignments()
-      const r1 = await createReport()
-      const r2 = await createReport()
-      await assignReport({ reportId: r1 }, 'admin')
-      await assignReport({ reportId: r2 }, 'admin')
-
-      const result = await getAssignments({ limit: 50 })
-      expect(result.assignments.length).toBe(2)
-      expect(result.cursor).toBeDefined()
-    })
-
-    it('fetches next page using cursor', async () => {
-      await clearAssignments()
-      const r1 = await createReport()
-      const r2 = await createReport()
-      const r3 = await createReport()
-      await assignReport({ reportId: r1 }, 'admin')
-      await assignReport({ reportId: r2 }, 'admin')
-      await assignReport({ reportId: r3 }, 'admin')
-
-      const firstPage = await getAssignments({ limit: 2 })
-      expect(firstPage.assignments.length).toBe(2)
-      expect(firstPage.cursor).toBeDefined()
-
-      const secondPage = await getAssignments({
-        limit: 2,
-        cursor: firstPage.cursor,
-      })
-      expect(secondPage.assignments.length).toBe(1)
-      expect(secondPage.cursor).toBeDefined()
-
-      // Ensure no overlap between pages
-      const firstPageIds = firstPage.assignments.map((a) => a.id)
-      const secondPageIds = secondPage.assignments.map((a) => a.id)
-      for (const id of secondPageIds) {
-        expect(firstPageIds).not.toContain(id)
-      }
-    })
-
-    it('returns all assignments across pages', async () => {
-      await clearAssignments()
-      const r1 = await createReport()
-      const r2 = await createReport()
-      const r3 = await createReport()
-      await assignReport({ reportId: r1 }, 'admin')
-      await assignReport({ reportId: r2 }, 'admin')
-      await assignReport({ reportId: r3 }, 'admin')
-
-      // Collect all assignments via pagination
-      const allAssignments: typeof firstPage.assignments = []
-      let cursor: string | undefined
-      const firstPage = await getAssignments({ limit: 1 })
-      allAssignments.push(...firstPage.assignments)
-      cursor = firstPage.cursor
-
-      while (cursor) {
-        const page = await getAssignments({ limit: 1, cursor })
-        allAssignments.push(...page.assignments)
-        cursor = page.cursor
-      }
-
-      expect(allAssignments.length).toBe(3)
-      // Verify all unique
-      const ids = allAssignments.map((a) => a.id)
-      expect(new Set(ids).size).toBe(3)
-    })
-
-    it('applies filters alongside pagination', async () => {
-      await clearAssignments()
-      const r1 = await createReport()
-      const r2 = await createReport()
-      const r3 = await createReport()
-      await assignReport({ reportId: r1 }, 'admin')
-      await assignReport({ reportId: r2 }, 'admin')
-      await assignReport({ reportId: r3 }, 'moderator')
-
-      const result = await getAssignments({
-        dids: [network.ozone.adminAccnt.did],
-        limit: 1,
-      })
-      expect(result.assignments.length).toBe(1)
-      expect(result.assignments[0].moderator?.did).toBe(
-        network.ozone.adminAccnt.did,
-      )
-      expect(result.cursor).toBeDefined()
-
-      const nextPage = await getAssignments({
-        dids: [network.ozone.adminAccnt.did],
-        limit: 1,
-        cursor: result.cursor,
-      })
-      expect(nextPage.assignments.length).toBe(1)
-      expect(nextPage.assignments[0].moderator?.did).toBe(
-        network.ozone.adminAccnt.did,
-      )
-    })
-  })
-
-  it('hydrates queue when queueId is provided', async () => {
-    const reportId = await createReport()
-    const assignment = await assignReport({ reportId, queueId }, 'admin')
-    expect(assignment.reportId).toBe(reportId)
-    expect(assignment.queue).toBeDefined()
-    expect(assignment.queue!.id).toBe(queueId)
-    expect(assignment.queue!.name).toBe('Report Queue')
-    expect(assignment.queue!.subjectTypes).toEqual(['account'])
-  })
-
-  it('omits queue when no queueId is provided', async () => {
-    const reportId = await createReport()
-    const assignment = await assignReport({ reportId }, 'admin')
-    expect(assignment.reportId).toBe(reportId)
-    expect(assignment.queue).toBeUndefined()
-  })
-
-  it('hydrates queue in getAssignments', async () => {
-    await clearAssignments()
-    const reportId = await createReport()
-    await assignReport({ reportId, queueId }, 'admin')
-    const result = await getAssignments({ reportIds: [reportId] })
-    expect(result.assignments.length).toBe(1)
-    expect(result.assignments[0].queue).toBeDefined()
-    expect(result.assignments[0].queue!.id).toBe(queueId)
-    expect(result.assignments[0].queue!.name).toBe('Report Queue')
-  })
-
-  it('cannot double assign', async () => {
-    const reportId = await createReport()
-    await assignReport({ reportId }, 'moderator')
-    await expect(assignReport({ reportId }, 'admin')).rejects.toThrow(
-      'Report already assigned',
-    )
-  })
-
-  describe('isPermanent', () => {
-    it('creates a permanent assignment with no endAt', async () => {
-      const reportId = await createReport()
-      const assignment = await assignReport(
-        { reportId, isPermanent: true },
-        'moderator',
-      )
-      expect(assignment.reportId).toBe(reportId)
-      expect(assignment.endAt).toBeUndefined()
-    })
-
-    it('upgrades an active assignment to permanent', async () => {
-      const reportId = await createReport()
-      const temp = await assignReport({ reportId }, 'moderator')
-      expect(temp.endAt).toBeDefined()
-
-      const permanent = await assignReport(
-        { reportId, isPermanent: true },
-        'moderator',
-      )
-      expect(permanent.id).toBe(temp.id)
-      expect(permanent.endAt).toBeUndefined()
-    })
-
-    it('permanent assignment is unassignable', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      const unassigned = await unassignReport({ reportId }, 'moderator')
-      expect(new Date(unassigned.endAt!).getTime()).toBeLessThanOrEqual(
-        new Date().getTime(),
-      )
-    })
-
-    it('throws AlreadyAssigned when another user has a permanent assignment', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      await expect(
-        assignReport({ reportId, isPermanent: true }, 'admin'),
-      ).rejects.toThrow('Report already assigned')
-    })
-
-    it('throws AlreadyAssigned for non-permanent assignment when another user holds permanent', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      await expect(assignReport({ reportId }, 'admin')).rejects.toThrow(
-        'Report already assigned',
-      )
-    })
-
-    it('records assignedTo in activity meta when admin assigns to another mod', async () => {
-      const reportId = await createReport()
-      const assignment = await assignReport(
-        { reportId, isPermanent: true, did: network.ozone.moderatorAccnt.did },
-        'admin',
-      )
-      expect(assignment.reportId).toBe(reportId)
-      expect(assignment.moderator?.did).toBe(network.ozone.moderatorAccnt.did)
-
-      const { activities } = await listActivities({ reportId })
-      const assignmentActivity = activities.find(
-        (a) =>
-          a.activity.$type === 'tools.ozone.report.defs#assignmentActivity',
-      )
-      expect(assignmentActivity).toBeDefined()
-      expect(assignmentActivity!.meta?.assignedTo).toBe(
-        network.ozone.moderatorAccnt.did,
-      )
-      expect(assignmentActivity!.createdBy).toBe(network.ozone.adminAccnt.did)
-    })
-
-    it('non-admin cannot assign to a different user', async () => {
-      const reportId = await createReport()
-      await expect(
-        assignReport(
-          { reportId, isPermanent: true, did: network.ozone.adminAccnt.did },
-          'moderator',
-        ),
-      ).rejects.toThrow('Unauthorized')
-    })
-
-    it('assignedTo equals createdBy when mod assigns to self', async () => {
-      const reportId = await createReport()
-      await assignReport(
-        { reportId, isPermanent: true, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-
-      const { activities } = await listActivities({ reportId })
-      const assignmentActivity = activities.find(
-        (a) =>
-          a.activity.$type === 'tools.ozone.report.defs#assignmentActivity',
-      )
-      expect(assignmentActivity).toBeDefined()
-      expect(assignmentActivity!.meta?.assignedTo).toBe(
-        network.ozone.moderatorAccnt.did,
-      )
-      expect(assignmentActivity!.createdBy).toBe(
-        network.ozone.moderatorAccnt.did,
-      )
-    })
-
-    it('same user can call isPermanent again idempotently', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      const again = await assignReport(
-        { reportId, isPermanent: true },
-        'moderator',
-      )
-      expect(again.endAt).toBeUndefined()
-    })
-
-    it('permanent assignment appears in onlyActive filter', async () => {
-      await clearAssignments()
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      const result = await getAssignments({ reportIds: [reportId] })
-      expect(result.assignments.length).toBe(1)
-      expect(result.assignments[0].endAt).toBeUndefined()
-    })
-  })
-
-  describe('unassign returns report to queue', () => {
-    const getReportStatus = async (reportId: number) => {
-      const row = await network.ozone.ctx.db.db
-        .selectFrom('report')
-        .select('status')
-        .where('id', '=', reportId)
-        .executeTakeFirstOrThrow()
-      return row.status
-    }
-
-    it('flips status from assigned back to queued and logs queueActivity', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, queueId, isPermanent: true }, 'moderator')
-      expect(await getReportStatus(reportId)).toBe('assigned')
-
-      await unassignReport({ reportId }, 'moderator')
-      expect(await getReportStatus(reportId)).toBe('queued')
-
-      const { activities } = await listActivities({ reportId })
-      const queueActivity = activities.find(
-        (a) => a.activity.$type === 'tools.ozone.report.defs#queueActivity',
-      )
-      expect(queueActivity).toBeDefined()
-      if ('previousStatus' in queueActivity!.activity) {
-        expect(queueActivity!.activity.previousStatus).toBe('assigned')
-      }
-      expect(queueActivity!.createdBy).toBe(network.ozone.moderatorAccnt.did)
-      expect(queueActivity!.isAutomated).toBe(false)
-    })
-
-    it('flips status from assigned back to open when assignment had no queueId', async () => {
-      const reportId = await createReport()
-      await assignReport({ reportId, isPermanent: true }, 'moderator')
-      expect(await getReportStatus(reportId)).toBe('assigned')
-
-      await unassignReport({ reportId }, 'moderator')
-      // No queueId on the assignment, so the report goes back to 'open'.
-      expect(await getReportStatus(reportId)).toBe('open')
-
-      const { activities } = await listActivities({ reportId })
-      const queueActivity = activities.find(
-        (a) => a.activity.$type === 'tools.ozone.report.defs#queueActivity',
-      )
-      expect(queueActivity).toBeUndefined()
-    })
-  })
-})

package/tests/report-muting.test.ts

@@ -1,100 +0,0 @@
-import {
-  ComAtprotoModerationDefs,
-  ToolsOzoneModerationDefs,
-} from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import {
-  REVIEWNONE,
-  REVIEWOPEN,
-} from '../src/lexicon/types/tools/ozone/moderation/defs.js'
-
-describe('report-muting', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_report_muting',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const assertSubjectStatus = async (
-    subject: string,
-    status?: string,
-  ): Promise<ToolsOzoneModerationDefs.SubjectStatusView | undefined> => {
-    const res = await modClient.queryStatuses({
-      subject,
-    })
-    expect(res.subjectStatuses[0]?.reviewState).toEqual(status)
-    return res.subjectStatuses[0]
-  }
-
-  it('does not change reviewState when muted reporter reports', async () => {
-    const bobsPostSubject = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[sc.dids.bob][1].ref.uriStr,
-      cid: sc.posts[sc.dids.bob][1].ref.cidStr,
-    }
-    const carolsAccountSubject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.carol,
-    }
-
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventMuteReporter',
-        durationInHours: 24,
-      },
-      subject: carolsAccountSubject,
-    })
-    await sc.createReport({
-      reportedBy: sc.dids.carol,
-      reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
-      reason: 'misleading',
-      subject: bobsPostSubject,
-    })
-
-    // Verify that a subject status was not created for bob's post since the reporter was muted
-    await assertSubjectStatus(bobsPostSubject.uri, REVIEWNONE)
-    // Verify, however, that the event was logged
-    await modClient.queryEvents({
-      subject: bobsPostSubject.uri,
-    })
-
-    // Verify that reporting mute duration is stored for the reporter
-    const carolsStatus = await assertSubjectStatus(sc.dids.carol, REVIEWNONE)
-    expect(
-      new Date(`${carolsStatus?.muteReportingUntil}`).getTime(),
-    ).toBeGreaterThan(Date.now())
-
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventUnmuteReporter',
-      },
-      subject: carolsAccountSubject,
-    })
-    await sc.createReport({
-      reportedBy: sc.dids.carol,
-      reasonType: ComAtprotoModerationDefs.REASONMISLEADING,
-      reason: 'misleading',
-      subject: bobsPostSubject,
-    })
-
-    // Verify that a subject status was created for bob's post since the reporter was no longer muted
-    await assertSubjectStatus(bobsPostSubject.uri, REVIEWOPEN)
-  })
-})