@atproto/ozone 0.2.9 → 0.2.11

package/tests/report-routing.test.ts

@@ -1,245 +0,0 @@
-import AtpAgent from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-
-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)
-    })
-  })
-})