@atproto/ozone 0.1.172 → 0.1.174

package/tests/report-reassign-queue.test.ts

@@ -0,0 +1,340 @@
+import AtpAgent from '@atproto/api'
+import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
+import { ids } from '../src/lexicon/lexicons'
+import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs'
+
+const DEFS = 'tools.ozone.report.defs'
+
+describe('report-reassign-queue', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  // Track queue IDs created during each test so afterEach can soft-delete them.
+  // Soft-deleted queues are filtered out of `checkConflict`, so tests are free
+  // to reuse the same queue configuration without tripping ConflictingQueue.
+  const createdQueueIds: number[] = []
+
+  const modHeaders = async (
+    nsid: string,
+    role: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) => network.ozone.modHeaders(nsid, role)
+
+  const createReport = async (subjectDid: string) => {
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: subjectDid,
+      },
+      reportedBy: sc.dids.bob,
+    })
+    await network.processAll()
+
+    const { data } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: subjectDid },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    const report = data.reports[0]
+    if (!report) throw new Error(`No report found for subject ${subjectDid}`)
+    return report
+  }
+
+  const createQueue = async (
+    overrides: {
+      name?: string
+      subjectTypes?: string[]
+      reportTypes?: string[]
+    } = {},
+  ) => {
+    const name = overrides.name ?? `q-${Date.now()}-${Math.random()}`
+    const input = {
+      name,
+      subjectTypes: overrides.subjectTypes ?? ['account'],
+      reportTypes: overrides.reportTypes ?? [
+        'com.atproto.moderation.defs#reasonSpam',
+      ],
+    }
+    const { data } = await agent.tools.ozone.queue.createQueue(input, {
+      encoding: 'application/json',
+      headers: await modHeaders(ids.ToolsOzoneQueueCreateQueue),
+    })
+    createdQueueIds.push(data.queue.id)
+    return data
+  }
+
+  const deleteQueue = async (queueId: number) =>
+    agent.tools.ozone.queue.deleteQueue(
+      { queueId },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneQueueDeleteQueue),
+      },
+    )
+
+  const closeReport = async (reportId: number) => {
+    await agent.tools.ozone.report.createActivity(
+      {
+        reportId,
+        activity: { $type: `${DEFS}#closeActivity` },
+      },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneReportCreateActivity),
+      },
+    )
+  }
+
+  const disableQueue = async (queueId: number) => {
+    return agent.tools.ozone.queue.updateQueue(
+      { queueId, enabled: false },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneQueueUpdateQueue),
+      },
+    )
+  }
+
+  const escalateReport = async (reportId: number) => {
+    await agent.tools.ozone.report.createActivity(
+      {
+        reportId,
+        activity: { $type: `${DEFS}#escalationActivity` },
+      },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneReportCreateActivity),
+      },
+    )
+  }
+
+  const reassignQueue = async (
+    input: { reportId: number; queueId: number; comment?: string },
+    role: 'admin' | 'moderator' | 'triage' = 'admin',
+  ) => {
+    return agent.tools.ozone.report.reassignQueue(input, {
+      encoding: 'application/json',
+      headers: await modHeaders(ids.ToolsOzoneReportReassignQueue, role),
+    })
+  }
+
+  const listActivities = async (reportId: number) => {
+    const { data } = await agent.tools.ozone.report.listActivities(
+      { reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportListActivities) },
+    )
+    return data
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_report_reassign_queue',
+    })
+    agent = network.ozone.getAgent()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterEach(async () => {
+    await Promise.all(
+      createdQueueIds.splice(0).map((id) => deleteQueue(id).catch(() => {})),
+    )
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('happy path: assigning to a real queue', () => {
+    it('transitions open → queued and writes an activity row', async () => {
+      const report = await createReport(sc.dids.alice)
+      const queue = await createQueue()
+
+      const { data } = await reassignQueue({
+        reportId: report.id,
+        queueId: queue.queue.id,
+        comment: 'Routing to spam queue for review',
+      })
+
+      expect(data.report.id).toBe(report.id)
+      expect(data.report.status).toBe('queued')
+      expect(data.report.queue?.id).toBe(queue.queue.id)
+      expect(data.report.queuedAt).toBeDefined()
+
+      const activities = await listActivities(report.id)
+      const queueActivity = activities.activities.find(
+        (a) => a.activity.$type === `${DEFS}#queueActivity`,
+      )
+      expect(queueActivity).toBeDefined()
+      expect(queueActivity!.internalNote).toBe(
+        'Routing to spam queue for review',
+      )
+      expect(queueActivity!.publicNote).toBeUndefined()
+      expect(queueActivity!.isAutomated).toBe(false)
+      expect((queueActivity!.activity as any).previousStatus).toBe('open')
+      expect(queueActivity!.meta!.toQueueId).toEqual(queue.queue.id)
+    })
+  })
+
+  describe('queue-to-queue reassignment', () => {
+    it('keeps status queued and records fromQueueId correctly', async () => {
+      const report = await createReport(sc.dids.carol)
+      const queueA = await createQueue()
+      // Second queue needs a distinct config to avoid ConflictingQueue.
+      const queueB = await createQueue({
+        reportTypes: ['com.atproto.moderation.defs#reasonViolation'],
+      })
+
+      await reassignQueue({ reportId: report.id, queueId: queueA.queue.id })
+
+      const { data } = await reassignQueue({
+        reportId: report.id,
+        queueId: queueB.queue.id,
+      })
+
+      expect(data.report.status).toBe('queued')
+      expect(data.report.queue?.id).toBe(queueB.queue.id)
+
+      const activities = await listActivities(report.id)
+      const queueActivities = activities.activities.filter(
+        (a) => a.activity.$type === `${DEFS}#queueActivity`,
+      )
+      // Sorted DESC, so [0] is the most recent.
+      expect(queueActivities.length).toBeGreaterThanOrEqual(2)
+      expect((queueActivities[0].activity as any).previousStatus).toBe('queued')
+      expect(queueActivities[0].meta).toEqual({
+        fromQueueId: queueA.queue.id,
+        toQueueId: queueB.queue.id,
+      })
+    })
+  })
+
+  describe('unassignment (queueId = -1)', () => {
+    it('transitions queued → open and clears queuedAt', async () => {
+      const report = await createReport(sc.dids.dan)
+      const queue = await createQueue()
+
+      await reassignQueue({ reportId: report.id, queueId: queue.queue.id })
+
+      const { data } = await reassignQueue({
+        reportId: report.id,
+        queueId: -1,
+      })
+
+      expect(data.report.status).toBe('open')
+      expect(data.report.queue).toBeUndefined()
+      expect(data.report.queuedAt).toBeUndefined()
+
+      const activities = await listActivities(report.id)
+      const latest = activities.activities[0]
+      expect(latest.activity.$type).toBe(`${DEFS}#queueActivity`)
+      expect((latest.activity as any).previousStatus).toBe('queued')
+      expect(latest.meta).toEqual({
+        fromQueueId: queue.queue.id,
+        toQueueId: -1,
+      })
+    })
+  })
+
+  describe('errors', () => {
+    it('throws ReportClosed when report is closed', async () => {
+      const report = await createReport(sc.dids.alice)
+      await closeReport(report.id)
+      const queue = await createQueue()
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: queue.queue.id }),
+      ).rejects.toThrow(/ReportClosed|closed/)
+    })
+
+    it('throws AlreadyInTargetQueue when target equals current queue', async () => {
+      const report = await createReport(sc.dids.alice)
+      const queue = await createQueue()
+      await reassignQueue({ reportId: report.id, queueId: queue.queue.id })
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: queue.queue.id }),
+      ).rejects.toThrow(/AlreadyInTargetQueue|already/)
+    })
+
+    it('throws AlreadyInTargetQueue when unassigning a never-queued report', async () => {
+      const report = await createReport(sc.dids.alice)
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: -1 }),
+      ).rejects.toThrow(/AlreadyInTargetQueue|already/)
+    })
+
+    it('throws QueueNotFound when target queue does not exist', async () => {
+      const report = await createReport(sc.dids.alice)
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: 999999 }),
+      ).rejects.toThrow(/QueueNotFound|not found/)
+    })
+
+    it('throws QueueNotFound when target queue is soft-deleted', async () => {
+      const report = await createReport(sc.dids.alice)
+      const queue = await createQueue()
+      await deleteQueue(queue.queue.id)
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: queue.queue.id }),
+      ).rejects.toThrow(/QueueNotFound|not found/)
+    })
+
+    it('throws QueueDisabled when target queue is disabled', async () => {
+      const report = await createReport(sc.dids.alice)
+      const queue = await createQueue()
+      await disableQueue(queue.queue.id)
+
+      await expect(
+        reassignQueue({ reportId: report.id, queueId: queue.queue.id }),
+      ).rejects.toThrow(/QueueDisabled|disabled/)
+    })
+
+    it('throws ReportNotFound when report does not exist', async () => {
+      const queue = await createQueue()
+
+      await expect(
+        reassignQueue({ reportId: 999999, queueId: queue.queue.id }),
+      ).rejects.toThrow(/ReportNotFound|not found/)
+    })
+  })
+
+  describe('status-preserving cases', () => {
+    it('keeps escalated status when reassigning an escalated report', async () => {
+      const report = await createReport(sc.dids.alice)
+      await escalateReport(report.id)
+      const queue = await createQueue()
+
+      const { data } = await reassignQueue({
+        reportId: report.id,
+        queueId: queue.queue.id,
+      })
+
+      expect(data.report.status).toBe('escalated')
+      expect(data.report.queue?.id).toBe(queue.queue.id)
+
+      const activities = await listActivities(report.id)
+      const latest = activities.activities[0]
+      expect(latest.activity.$type).toBe(`${DEFS}#queueActivity`)
+      expect((latest.activity as any).previousStatus).toBe('escalated')
+    })
+  })
+
+  describe('auth', () => {
+    it('allows triage role to reassign', async () => {
+      const report = await createReport(sc.dids.alice)
+      const queue = await createQueue()
+
+      const { data } = await reassignQueue(
+        { reportId: report.id, queueId: queue.queue.id },
+        'triage',
+      )
+
+      expect(data.report.status).toBe('queued')
+    })
+  })
+})

package/tests/report-routing.test.ts

@@ -0,0 +1,245 @@
+import AtpAgent from '@atproto/api'
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+import { ids } from '../src/lexicon/lexicons'
+
+const REASON_SPAM = 'com.atproto.moderation.defs#reasonSpam'
+const REASON_THREAT = 'tools.ozone.report.defs#reasonViolenceThreats'
+const REASON_MISLEADING = 'com.atproto.moderation.defs#reasonMisleading'
+
+describe('queue-router', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  const modHeaders = (nsid: string) => network.ozone.modHeaders(nsid, 'admin')
+
+  const createQueue = async (input: {
+    name: string
+    subjectTypes: string[]
+    reportTypes: string[]
+    collection?: string
+  }) => {
+    const { data } = await agent.tools.ozone.queue.createQueue(input, {
+      encoding: 'application/json',
+      headers: await modHeaders(ids.ToolsOzoneQueueCreateQueue),
+    })
+    return data.queue
+  }
+
+  const deleteQueue = async (queueId: number) => {
+    await agent.tools.ozone.queue.deleteQueue(
+      { queueId },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneQueueDeleteQueue),
+      },
+    )
+  }
+
+  // Creates a report event (account-level) directly via modClient for a given DID + reason
+  const reportAccount = async (did: string, reportType: string) => {
+    await modClient.emitEvent({
+      event: {
+        $type: 'tools.ozone.moderation.defs#modEventReport',
+        reportType,
+        comment: 'automated test report',
+      },
+      subject: { $type: 'com.atproto.admin.defs#repoRef', did },
+    })
+  }
+
+  // Returns the most recent report row for a subject directly from the DB.
+  // Pass a DID for account subjects or an at:// URI for record subjects.
+  const getLatestReportForSubject = async (subjectOrUri: string) => {
+    const db = network.ozone.daemon.ctx.db
+    const isDid = subjectOrUri.startsWith('did:')
+    let query = db.db
+      .selectFrom('report as r')
+      .innerJoin('moderation_event as me', 'me.id', 'r.eventId')
+      .select(['r.id', 'r.queueId', 'r.queuedAt', 'r.status'])
+      .orderBy('r.id', 'desc')
+      .limit(1)
+    if (isDid) {
+      query = query
+        .where('me.subjectDid', '=', subjectOrUri)
+        .where('me.subjectUri', 'is', null)
+    } else {
+      query = query.where('me.subjectUri', '=', subjectOrUri)
+    }
+    return query.executeTakeFirstOrThrow()
+  }
+
+  const getLatest = async () => {
+    const { data } = await agent.tools.ozone.report.getLatestReport(
+      {},
+      { headers: await modHeaders(ids.ToolsOzoneReportGetLatestReport) },
+    )
+    return data.report
+  }
+
+  const routeReports = async (startReportId: number, endReportId: number) => {
+    const { data } = await agent.tools.ozone.queue.routeReports(
+      { startReportId, endReportId },
+      {
+        encoding: 'application/json',
+        headers: await modHeaders(ids.ToolsOzoneQueueRouteReports),
+      },
+    )
+    return data
+  }
+
+  const clearQueues = async () => {
+    const db = network.ozone.ctx.db.db
+    await db.deleteFrom('report_queue').execute()
+  }
+
+  let spamAccountQueueId: number
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_report_routing',
+    })
+    agent = network.ozone.getAgent()
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+    await clearQueues()
+    const [spamAccountQueue] = await Promise.all([
+      createQueue({
+        name: 'QR: Spam Accounts',
+        subjectTypes: ['account'],
+        reportTypes: [REASON_SPAM],
+      }),
+    ])
+    spamAccountQueueId = spamAccountQueue.id
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('routes unassigned AND unmatched reports to a newly created queue', async () => {
+    // Create unmatchable report (queueId will be set to -1 by daemon)
+    await reportAccount(sc.dids.bob, REASON_MISLEADING)
+    await network.ozone.daemon.ctx.queueRouter.routeReports()
+    const unmatchedReport = await getLatestReportForSubject(sc.dids.bob)
+    expect(unmatchedReport.queueId).toBe(-1)
+
+    // Create an unassigned (queueId IS NULL) report — this state no longer
+    // arises from the normal flow, since the daemon always sets a queueId,
+    // but the manual routeReports endpoint still handles legacy NULL rows.
+    // Simulate it via a direct DB insert of a report event + report row.
+    await reportAccount(sc.dids.carol, REASON_MISLEADING)
+    const carolEvent = await network.ozone.daemon.ctx.db.db
+      .selectFrom('moderation_event')
+      .select(['id', 'subjectDid', 'meta'])
+      .where('subjectDid', '=', sc.dids.carol)
+      .where('action', '=', 'tools.ozone.moderation.defs#modEventReport')
+      .orderBy('id', 'desc')
+      .limit(1)
+      .executeTakeFirstOrThrow()
+    const now = new Date().toISOString()
+    await network.ozone.daemon.ctx.db.db
+      .insertInto('report')
+      .values({
+        eventId: carolEvent.id,
+        queueId: null,
+        actionEventIds: null,
+        actionNote: null,
+        isMuted: false,
+        status: 'open',
+        reportType: REASON_MISLEADING,
+        did: carolEvent.subjectDid,
+        recordPath: '',
+        subjectMessageId: null,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .execute()
+    const unassignedReport = await getLatestReportForSubject(sc.dids.carol)
+    expect(unassignedReport.queueId).toBeNull()
+
+    // Create a queue that now matches misleading account reports
+    const misleadingQueue = await createQueue({
+      name: 'QR: Misleading Accounts',
+      subjectTypes: ['account'],
+      reportTypes: [REASON_MISLEADING],
+    })
+
+    // Re-route both reports
+    const startId = Math.min(unmatchedReport.id, unassignedReport.id)
+    const endId = Math.max(unmatchedReport.id, unassignedReport.id)
+    const result = await routeReports(startId, endId)
+    expect(result.assigned).toBe(2)
+    expect(result.unmatched).toBe(0)
+
+    // Verify both reports match
+    const unmatchedAfter = await getLatestReportForSubject(sc.dids.bob)
+    expect(unmatchedAfter.queueId).toBe(misleadingQueue.id)
+    const unassignedAfter = await getLatestReportForSubject(sc.dids.carol)
+    expect(unassignedAfter.queueId).toBe(misleadingQueue.id)
+
+    // cleanup
+    await deleteQueue(misleadingQueue.id)
+  })
+
+  it('skips reports already assigned to a valid queue', async () => {
+    await reportAccount(sc.dids.bob, REASON_SPAM)
+    await network.ozone.daemon.ctx.queueRouter.routeReports()
+
+    const reportBob = await getLatestReportForSubject(sc.dids.bob)
+    expect(reportBob.queueId).toBe(spamAccountQueueId)
+
+    // Report is already assigned — endpoint only processes null/unmatched
+    const result = await routeReports(reportBob.id, reportBob.id)
+    expect(result.assigned).toBe(0)
+    expect(result.unmatched).toBe(0)
+  })
+
+  it('rejects when startReportId > endReportId', async () => {
+    await expect(routeReports(100, 50)).rejects.toThrow(
+      'startReportId must be less than or equal to endReportId',
+    )
+  })
+
+  it('rejects when more than 5000 reports', async () => {
+    await expect(routeReports(100, 5101)).rejects.toThrow(
+      'Cannot route more than 5000 reports at a time',
+    )
+  })
+
+  describe('get latest report', () => {
+    it('returns latest report', async () => {
+      // Create a new report so we know what the latest should be
+      await reportAccount(sc.dids.dan, REASON_SPAM)
+      // Report rows are inserted asynchronously by the queue-router daemon —
+      // drain it before querying.
+      await network.processAll()
+
+      const latest = await getLatest()
+      expect(latest).toBeDefined()
+      expect(latest.id).toBeGreaterThan(0)
+
+      // Verify it matches the DB
+      const dbReport = await getLatestReportForSubject(sc.dids.dan)
+      expect(latest.id).toBe(dbReport.id)
+    })
+
+    it('returns a newer report after creating one', async () => {
+      const first = await getLatest()
+
+      await reportAccount(sc.dids.alice, REASON_THREAT)
+      await network.processAll()
+
+      const second = await getLatest()
+      expect(second.id).toBeGreaterThan(first.id)
+    })
+  })
+})