@atproto/ozone 0.2.8 → 0.2.11

package/tests/queue-assignment.test.ts

@@ -1,428 +0,0 @@
-import AtpAgent, {
-  ToolsOzoneQueueAssignModerator,
-  ToolsOzoneQueueGetAssignments,
-  ToolsOzoneQueueUnassignModerator,
-} from '@atproto/api'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-
-describe('queue', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let q1: number
-  let q2: number
-  let q3: number
-
-  const assign = async (
-    input: ToolsOzoneQueueAssignModerator.InputSchema,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.queue.assignModerator(input, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneQueueAssignModerator,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const getAssignments = async (
-    input: ToolsOzoneQueueGetAssignments.QueryParams,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.queue.getAssignments(input, {
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneQueueGetAssignments,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  const unassign = async (
-    input: ToolsOzoneQueueUnassignModerator.InputSchema,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    await agent.tools.ozone.queue.unassignModerator(input, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneQueueUnassignModerator,
-        callerRole,
-      ),
-    })
-  }
-
-  const clearAssignments = async () => {
-    await network.ozone.ctx.db.db.deleteFrom('moderator_assignment').execute()
-  }
-
-  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
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'queue_assignment',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-
-    // Clean up any leftover data from previous runs
-    await network.ozone.ctx.db.db.deleteFrom('moderator_assignment').execute()
-    await network.ozone.ctx.db.db.deleteFrom('report_queue').execute()
-
-    // Seed queues and capture their actual IDs
-    const queue1 = await createQueue('Queue 1', [
-      'com.atproto.moderation.defs#reasonSpam',
-    ])
-    const queue2 = await createQueue('Queue 2', [
-      'com.atproto.moderation.defs#reasonOther',
-    ])
-    const queue3 = await createQueue('Queue 3', [
-      'com.atproto.moderation.defs#reasonMisleading',
-    ])
-    q1 = queue1.queue.id
-    q2 = queue2.queue.id
-    q3 = queue3.queue.id
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('get active assignments', async () => {
-    await assign({ queueId: q1, did: network.ozone.adminAccnt.did }, 'admin')
-    const result = await getAssignments({ onlyActive: true })
-
-    expect(result.assignments.length).toBeGreaterThanOrEqual(1)
-    const queueIds = result.assignments.map((a) => a.queue.id)
-    expect(queueIds).toContain(q1)
-  })
-
-  it('filters assignments by queueId', async () => {
-    await assign(
-      { queueId: q1, did: network.ozone.moderatorAccnt.did },
-      'moderator',
-    )
-
-    const result = await getAssignments({
-      queueIds: [q1],
-    })
-
-    expect(result.assignments.length).toBeGreaterThanOrEqual(1)
-    expect(result.assignments[0].queue.id).toBe(q1)
-  })
-
-  it('filters assignments by dids', async () => {
-    await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-    await assign({ queueId: q1, did: sc.dids.carol }, 'admin')
-
-    const result = await getAssignments({
-      dids: [sc.dids.bob],
-    })
-
-    expect(result.assignments.length).toBeGreaterThanOrEqual(1)
-  })
-
-  it('get assignments for a user', async () => {
-    await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-
-    const result = await getAssignments({
-      dids: [sc.dids.bob],
-    })
-
-    expect(result.assignments.length).toBeGreaterThanOrEqual(1)
-  })
-
-  it('get active assignments for queue', async () => {
-    await clearAssignments()
-    await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-    const result = await getAssignments({
-      queueIds: [q1],
-      onlyActive: true,
-    })
-    expect(result.assignments.length).toBe(1)
-  })
-
-  it('get all assignments for queue', async () => {
-    await clearAssignments()
-    await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-    const result = await getAssignments({
-      queueIds: [q1],
-      onlyActive: false,
-    })
-    expect(result.assignments.length).toBe(1)
-  })
-
-  it('invalid queue ID throws error', async () => {
-    const p = assign(
-      { queueId: 9999, did: network.ozone.adminAccnt.did },
-      'admin',
-    )
-    await expect(p).rejects.toThrow('Invalid queue')
-  })
-
-  describe('pagination', () => {
-    it('paginates assignments with limit', async () => {
-      await clearAssignments()
-      // Create assignments for multiple queues
-      await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q2, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q3, did: sc.dids.alice }, '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()
-      await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q2, did: sc.dids.alice }, 'admin')
-
-      const result = await getAssignments({ limit: 50 })
-      expect(result.assignments.length).toBe(2)
-      // Cursor always points to the last item returned, even when all results fit in one page
-      expect(result.cursor).toBeDefined()
-    })
-
-    it('fetches next page using cursor', async () => {
-      await clearAssignments()
-      await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q2, did: sc.dids.bob }, 'admin')
-      await assign({ queueId: q3, did: sc.dids.carol }, '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)
-      // Cursor points to the last item returned; a subsequent fetch with this cursor would return 0 results
-      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()
-      await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q2, did: sc.dids.bob }, 'admin')
-      await assign({ queueId: q3, did: sc.dids.carol }, '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()
-      await assign({ queueId: q1, did: sc.dids.alice }, 'admin')
-      await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-      await assign({ queueId: q2, did: sc.dids.carol }, 'admin')
-
-      const result = await getAssignments({ queueIds: [q1], limit: 1 })
-      expect(result.assignments.length).toBe(1)
-      expect(result.assignments[0].queue.id).toBe(q1)
-      expect(result.cursor).toBeDefined()
-
-      const nextPage = await getAssignments({
-        queueIds: [q1],
-        limit: 1,
-        cursor: result.cursor,
-      })
-      expect(nextPage.assignments.length).toBe(1)
-      expect(nextPage.assignments[0].queue.id).toBe(q1)
-    })
-  })
-
-  describe('admin', () => {
-    it('should be able to assign self to a queue', async () => {
-      const assignment = await assign(
-        { queueId: q1, did: network.ozone.adminAccnt.did },
-        'admin',
-      )
-
-      expect(assignment.queue.id).toBe(q1)
-      expect(assignment.moderator?.did).toBe(network.ozone.adminAccnt.did)
-
-      const assignments = await getAssignments({ onlyActive: true }, 'admin')
-      const queueIds = assignments.assignments.map((a) => a.queue.id)
-      expect(queueIds).toContain(q1)
-    })
-    it('should be able to assign a mod to a queue', async () => {
-      const assignment = await assign(
-        { queueId: q1, did: sc.dids.bob },
-        'admin',
-      )
-
-      expect(assignment.queue.id).toBe(q1)
-
-      const assignments = await getAssignments({ onlyActive: true }, 'admin')
-      const queueIds = assignments.assignments.map((a) => a.queue.id)
-      expect(queueIds).toContain(q1)
-    })
-    it('should be able to assign multiple mods to a queue', async () => {
-      await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-      await assign({ queueId: q1, did: sc.dids.carol }, 'admin')
-      const assignments = await getAssignments(
-        { onlyActive: true, queueIds: [q1] },
-        'admin',
-      )
-      expect(assignments.assignments.length).toBeGreaterThanOrEqual(2)
-    })
-  })
-
-  describe('moderator', () => {
-    it('should be able to assign self to a queue', async () => {
-      const assignment = await assign(
-        { queueId: q1, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-
-      expect(assignment.queue.id).toBe(q1)
-      expect(assignment.moderator?.did).toBe(network.ozone.moderatorAccnt.did)
-
-      const assignments = await getAssignments({ onlyActive: true }, 'admin')
-      const queueIds = assignments.assignments.map((a) => a.queue.id)
-      expect(queueIds).toContain(q1)
-    })
-    it('should not be able to assign another user to a queue', async () => {
-      const p = assign(
-        { queueId: q1, did: network.ozone.adminAccnt.did },
-        'moderator',
-      )
-      await expect(p).rejects.toThrow('Unauthorized')
-    })
-
-    it('assigns permanently with no endAt', async () => {
-      const assignment = await assign(
-        { queueId: q1, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-      expect(assignment.endAt).toBeUndefined()
-    })
-  })
-
-  describe('triage', () => {
-    it('should not be able to assign self to a queue', async () => {
-      const p = assign(
-        { queueId: q1, did: network.ozone.triageAccnt.did },
-        'triage',
-      )
-      await expect(p).rejects.toThrow('Unauthorized')
-    })
-    it('should not be able to assign another user to a queue', async () => {
-      const p = assign(
-        { queueId: q1, did: network.ozone.adminAccnt.did },
-        'triage',
-      )
-      await expect(p).rejects.toThrow('Unauthorized')
-    })
-  })
-
-  describe('unassign', () => {
-    it('moderator can unassign self and assignment becomes inactive', async () => {
-      await clearAssignments()
-      await assign(
-        { queueId: q1, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-
-      await unassign(
-        { queueId: q1, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-
-      const active = await getAssignments({
-        queueIds: [q1],
-        dids: [network.ozone.moderatorAccnt.did],
-        onlyActive: true,
-      })
-      expect(active.assignments.length).toBe(0)
-    })
-
-    it('admin can unassign another moderator', async () => {
-      await clearAssignments()
-      await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-
-      await unassign({ queueId: q1, did: sc.dids.bob }, 'admin')
-
-      const active = await getAssignments({
-        queueIds: [q1],
-        dids: [sc.dids.bob],
-        onlyActive: true,
-      })
-      expect(active.assignments.length).toBe(0)
-    })
-
-    it('moderator cannot unassign another user', async () => {
-      await clearAssignments()
-      await assign({ queueId: q1, did: sc.dids.bob }, 'admin')
-
-      const p = unassign({ queueId: q1, did: sc.dids.bob }, 'moderator')
-      await expect(p).rejects.toThrow('Unauthorized')
-    })
-
-    it('triage cannot unassign', async () => {
-      await clearAssignments()
-      await assign({ queueId: q1, did: network.ozone.triageAccnt.did }, 'admin')
-
-      const p = unassign(
-        { queueId: q1, did: network.ozone.triageAccnt.did },
-        'triage',
-      )
-      await expect(p).rejects.toThrow('Unauthorized')
-    })
-
-    it('throws InvalidAssignment when no active assignment exists', async () => {
-      await clearAssignments()
-      const p = unassign(
-        { queueId: q1, did: network.ozone.moderatorAccnt.did },
-        'moderator',
-      )
-      await expect(p).rejects.toThrow('No active assignment')
-    })
-  })
-})