@atproto/ozone 0.2.9 → 0.2.11

package/tests/scheduled-action.test.ts

@@ -1,334 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import { forSnapshot } from './_util.js'
-
-const allStatuses = ['pending', 'executed', 'cancelled', 'failed']
-
-describe('scheduled action management', () => {
-  let network: TestNetwork
-  let adminAgent: AtpAgent
-  let modAgent: AtpAgent
-  let triageAgent: AtpAgent
-  let sc: SeedClient
-
-  const getAdminHeaders = async (route: string) => {
-    return {
-      headers: await network.ozone.modHeaders(route, 'admin'),
-    }
-  }
-
-  const getModHeaders = async (route: string) => {
-    return {
-      headers: await network.ozone.modHeaders(route, 'moderator'),
-    }
-  }
-
-  const getModEvent = async (params: {
-    subject: string
-    cancellation?: boolean
-  }) => {
-    const {
-      data: { events },
-    } = await adminAgent.tools.ozone.moderation.queryEvents(
-      {
-        subject: params.subject,
-        types: [
-          params.cancellation
-            ? 'tools.ozone.moderation.defs#cancelScheduledTakedownEvent'
-            : 'tools.ozone.moderation.defs#scheduleTakedownEvent',
-        ],
-      },
-      await getAdminHeaders(ids.ToolsOzoneModerationQueryEvents),
-    )
-    return events
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_scheduled_action_test',
-    })
-    adminAgent = network.ozone.getAgent()
-    modAgent = network.ozone.getAgent()
-    triageAgent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  describe('scheduleAction', () => {
-    const getTestAction = () => ({
-      action: {
-        $type: 'tools.ozone.moderation.scheduleAction#takedown',
-        comment: 'test',
-        policies: ['spam'],
-      },
-      subjects: [sc.dids.carol, sc.dids.bob],
-      createdBy: 'did:plc:moderator',
-      scheduling: {
-        executeAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour from now
-      },
-    })
-
-    it('allows admins to schedule actions', async () => {
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.scheduleAction(
-          getTestAction(),
-          await getAdminHeaders(ids.ToolsOzoneModerationScheduleAction),
-        )
-      const bobsModEvents = await getModEvent({ subject: sc.dids.bob })
-
-      expect(result.succeeded.length).toBe(2)
-      expect(result.failed.length).toBe(0)
-      expect(result.succeeded).toContain(sc.dids.carol)
-      expect(result.succeeded).toContain(sc.dids.bob)
-      expect(bobsModEvents.length).toBe(1)
-    })
-
-    it('rejects triage role from scheduling actions', async () => {
-      await expect(
-        triageAgent.tools.ozone.moderation.scheduleAction(getTestAction(), {
-          headers: await network.ozone.modHeaders(
-            ids.ToolsOzoneModerationScheduleAction,
-            'triage',
-          ),
-        }),
-      ).rejects.toThrow('Must be a moderator to schedule actions')
-    })
-
-    it('supports scheduling with time range (executeAfter/executeUntil)', async () => {
-      const rangeAction = {
-        ...getTestAction(),
-        subjects: [sc.dids.alice],
-        scheduling: {
-          executeAfter: new Date(Date.now() + 30 * 60 * 1000).toISOString(), // 30 min from now
-          executeUntil: new Date(Date.now() + 90 * 60 * 1000).toISOString(), // 90 min from now
-        },
-      }
-
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.scheduleAction(
-          rangeAction,
-          await getAdminHeaders(ids.ToolsOzoneModerationScheduleAction),
-        )
-      expect(result.succeeded.length).toBe(1)
-      expect(result.succeeded).toContain(sc.dids.alice)
-    })
-
-    it('prevents scheduling multiple actions for same subject', async () => {
-      const duplicateAction = {
-        ...getTestAction(),
-        subjects: [sc.dids.carol],
-        scheduling: {
-          executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000).toISOString(),
-        },
-      }
-
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.scheduleAction(
-          duplicateAction,
-          await getAdminHeaders(ids.ToolsOzoneModerationScheduleAction),
-        )
-      expect(result.succeeded.length).toBe(0)
-      expect(result.failed.length).toBe(1)
-      expect(result.failed[0].subject).toBe(sc.dids.carol)
-      expect(result.failed[0].error).toContain(
-        'A pending scheduled action already exists',
-      )
-    })
-
-    it('validates scheduling parameters', async () => {
-      const invalidAction = {
-        ...getTestAction(),
-        subjects: ['did:plc:test_invalid'],
-        scheduling: {
-          executeAfter: new Date(Date.now() + 90 * 60 * 1000).toISOString(),
-          executeUntil: new Date(Date.now() + 30 * 60 * 1000).toISOString(), // executeUntil before executeAfter
-        },
-      }
-
-      const { data } = await adminAgent.tools.ozone.moderation.scheduleAction(
-        invalidAction,
-        await getAdminHeaders(ids.ToolsOzoneModerationScheduleAction),
-      )
-
-      expect(data.failed.length).toBe(1)
-      expect(data.failed[0].subject).toBe('did:plc:test_invalid')
-      expect(data.failed[0].error).toContain(
-        'executeAfter must be before executeUntil',
-      )
-    })
-  })
-
-  describe('listScheduledActions', () => {
-    it('allows moderators to list all scheduled actions', async () => {
-      const { data: result } =
-        await modAgent.tools.ozone.moderation.listScheduledActions(
-          { statuses: allStatuses },
-          await getModHeaders(ids.ToolsOzoneModerationListScheduledActions),
-        )
-
-      expect(result.actions.length).toBeGreaterThan(0)
-      expect(forSnapshot(result.actions)).toMatchSnapshot()
-    })
-
-    it('allows filtering by subjects', async () => {
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.listScheduledActions(
-          {
-            subjects: [sc.dids.carol],
-            statuses: allStatuses,
-          },
-          await getAdminHeaders(ids.ToolsOzoneModerationListScheduledActions),
-        )
-
-      expect(result.actions.length).toBeGreaterThan(0)
-      result.actions.forEach((action) => {
-        expect(action.did).toBe(sc.dids.carol)
-      })
-    })
-
-    it('allows filtering by status', async () => {
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.listScheduledActions(
-          {
-            statuses: ['pending'],
-          },
-          await getAdminHeaders(ids.ToolsOzoneModerationListScheduledActions),
-        )
-
-      expect(result.actions.length).toBeGreaterThan(0)
-      result.actions.forEach((action) => {
-        expect(action.status).toBe('pending')
-      })
-    })
-
-    it('supports time range filtering', async () => {
-      const now = new Date()
-      const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000)
-      const twoHoursFromNow = new Date(now.getTime() + 2 * 60 * 60 * 1000)
-
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.listScheduledActions(
-          {
-            startsAfter: oneHourAgo.toISOString(),
-            endsBefore: twoHoursFromNow.toISOString(),
-            statuses: allStatuses,
-          },
-          await getAdminHeaders(ids.ToolsOzoneModerationListScheduledActions),
-        )
-
-      expect(result.actions.length).toBeGreaterThan(0)
-    })
-
-    it('supports pagination', async () => {
-      const headers = await getAdminHeaders(
-        ids.ToolsOzoneModerationListScheduledActions,
-      )
-      const { data: page1 } =
-        await adminAgent.tools.ozone.moderation.listScheduledActions(
-          { limit: 2, statuses: allStatuses },
-          headers,
-        )
-
-      expect(page1.actions.length).toBe(2)
-      expect(page1.cursor).toBeDefined()
-
-      const { data: page2 } =
-        await adminAgent.tools.ozone.moderation.listScheduledActions(
-          {
-            limit: 2,
-            statuses: allStatuses,
-            cursor: page1.cursor,
-          },
-          headers,
-        )
-
-      expect(page2.actions.length).toBeGreaterThan(0)
-      expect(page1.actions.map((a) => a.did)).not.toContain(
-        page2.actions[0].did,
-      )
-    })
-  })
-
-  describe('cancelScheduledActions', () => {
-    it('allows moderators to cancel scheduled actions', async () => {
-      const { data: result } =
-        await modAgent.tools.ozone.moderation.cancelScheduledActions(
-          {
-            subjects: [sc.dids.bob],
-          },
-          await getModHeaders(ids.ToolsOzoneModerationCancelScheduledActions),
-        )
-      const bobsModEvents = await getModEvent({
-        subject: sc.dids.bob,
-        cancellation: true,
-      })
-      expect(result.succeeded.length).toBe(1)
-      expect(result.failed.length).toBe(0)
-      expect(result.succeeded).toContain(sc.dids.bob)
-      expect(bobsModEvents.length).toBe(1)
-    })
-
-    it('allows admins to cancel scheduled actions', async () => {
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.cancelScheduledActions(
-          {
-            subjects: [sc.dids.carol],
-          },
-          await getAdminHeaders(ids.ToolsOzoneModerationCancelScheduledActions),
-        )
-
-      expect(result.succeeded.length).toBe(1)
-      expect(result.failed.length).toBe(0)
-      expect(result.succeeded).toContain(sc.dids.carol)
-
-      const {
-        data: { actions },
-      } = await adminAgent.tools.ozone.moderation.listScheduledActions(
-        {
-          statuses: allStatuses,
-          subjects: [sc.dids.carol],
-        },
-        await getAdminHeaders(ids.ToolsOzoneModerationListScheduledActions),
-      )
-
-      expect(actions[0].status).toBe('cancelled')
-    })
-
-    it('handles cancellation of non-existent actions', async () => {
-      const { data: result } =
-        await adminAgent.tools.ozone.moderation.cancelScheduledActions(
-          {
-            subjects: ['did:plc:nonexistent'],
-          },
-          await getAdminHeaders(ids.ToolsOzoneModerationCancelScheduledActions),
-        )
-
-      expect(result.succeeded.length).toBe(0)
-      expect(result.failed.length).toBe(1)
-      expect(result.failed[0].did).toBe('did:plc:nonexistent')
-      expect(result.failed[0].error).toContain(
-        'No pending scheduled actions found',
-      )
-    })
-
-    it('rejects triage moderators from cancelling actions', async () => {
-      await expect(
-        triageAgent.tools.ozone.moderation.cancelScheduledActions(
-          { subjects: [sc.dids.carol] },
-          {
-            headers: await network.ozone.modHeaders(
-              ids.ToolsOzoneModerationCancelScheduledActions,
-              'triage',
-            ),
-          },
-        ),
-      ).rejects.toThrow('Must be a moderator to cancel scheduled actions')
-    })
-  })
-})

package/tests/sequencer.test.ts

@@ -1,227 +0,0 @@
-import { readFromGenerator, wait } from '@atproto/common'
-import { randomStr } from '@atproto/crypto'
-import { EXAMPLE_LABELER, TestNetwork } from '@atproto/dev-env'
-import { Label } from '../src/lexicon/types/com/atproto/label/defs.js'
-import { LabelsEvt, Sequencer } from '../src/sequencer/index.js'
-import { Outbox } from '../src/sequencer/outbox.js'
-
-describe('sequencer', () => {
-  let network: TestNetwork
-  let sequencer: Sequencer
-
-  let totalEvts = 0
-  let lastSeen: number
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_sequencer',
-    })
-    // @ts-expect-error
-    sequencer = network.ozone.ctx.sequencer
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const loadFromDb = (lastSeen: number) => {
-    return sequencer.db.db
-      .selectFrom('label')
-      .selectAll()
-      .where('id', '>', lastSeen)
-      .orderBy('id', 'asc')
-      .execute()
-  }
-
-  const evtToDbRow = (e: LabelsEvt) => {
-    const { ver: _, ...label } = e.labels[0]
-    return {
-      id: e.seq,
-      ...label,
-      neg: !!label.neg,
-      cid: label.cid ? label.cid : '',
-      exp: null,
-      sig: label.sig ? Buffer.from(label.sig) : null,
-      signingKeyId: network.ozone.ctx.signingKeyId,
-    }
-  }
-
-  const caughtUp = (outbox: Outbox): (() => Promise<boolean>) => {
-    return async () => {
-      const lastEvt = await outbox.sequencer.curr()
-      if (lastEvt === null) return true
-      return outbox.lastSeen >= (lastEvt ?? 0)
-    }
-  }
-
-  const createLabels = async (count: number): Promise<Label[]> => {
-    const labels: Label[] = []
-    for (let i = 0; i < count; i++) {
-      const did = `did:example:${randomStr(10, 'base32')}`
-      const label = {
-        src: EXAMPLE_LABELER,
-        uri: did,
-        val: 'spam',
-        neg: false,
-        cts: new Date().toISOString(),
-      }
-      await network.ozone.ctx.db.transaction((dbTxn) =>
-        network.ozone.ctx.modService(dbTxn).createLabels([label]),
-      )
-      labels.push(label)
-    }
-    return labels
-  }
-
-  it('sends to outbox', async () => {
-    const count = 20
-    totalEvts += count
-    await createLabels(count)
-    const outbox = new Outbox(sequencer)
-    const evts = await readFromGenerator(outbox.events(-1), caughtUp(outbox))
-    expect(evts.length).toBe(totalEvts)
-
-    const fromDb = await loadFromDb(-1)
-    expect(evts.map(evtToDbRow)).toEqual(fromDb)
-
-    lastSeen = evts.at(-1)?.seq ?? lastSeen
-  })
-
-  it('sequences negative labels', async () => {
-    const count = 5
-    totalEvts += count
-    const created = await createLabels(count)
-    const toNegate = created
-      .slice(0, 2)
-      .map((l) => ({ ...l, neg: true, cts: new Date().toISOString() }))
-    await network.ozone.ctx
-      .modService(network.ozone.ctx.db)
-      .createLabels(toNegate)
-
-    const outbox = new Outbox(sequencer)
-    const evts = await readFromGenerator(
-      outbox.events(lastSeen),
-      caughtUp(outbox),
-    )
-    expect(evts.length).toBe(count)
-
-    const fromDb = await loadFromDb(lastSeen)
-    expect(evts.map(evtToDbRow)).toEqual(fromDb)
-    expect(evts[3].labels[0].uri).toEqual(toNegate[0].uri)
-    expect(evts[3].labels[0].neg).toBe(true)
-    expect(evts[4].labels[0].uri).toEqual(toNegate[1].uri)
-    expect(evts[4].labels[0].neg).toBe(true)
-
-    lastSeen = evts.at(-1)?.seq ?? lastSeen
-  })
-
-  it('handles cut over', async () => {
-    const count = 20
-    totalEvts += count
-    const outbox = new Outbox(sequencer)
-    const createPromise = createLabels(count)
-    const [evts] = await Promise.all([
-      readFromGenerator(outbox.events(-1), caughtUp(outbox), createPromise),
-      createPromise,
-    ])
-    expect(evts.length).toBe(totalEvts)
-
-    const fromDb = await loadFromDb(-1)
-    expect(evts.map(evtToDbRow)).toEqual(fromDb)
-
-    lastSeen = evts.at(-1)?.seq ?? lastSeen
-  })
-
-  it('only gets events after cursor', async () => {
-    const count = 20
-    totalEvts += count
-    const outbox = new Outbox(sequencer)
-    const createPromise = createLabels(count)
-    const [evts] = await Promise.all([
-      readFromGenerator(
-        outbox.events(lastSeen),
-        caughtUp(outbox),
-        createPromise,
-      ),
-      createPromise,
-    ])
-
-    // +1 because we send the lastSeen date as well
-    expect(evts.length).toBe(count)
-
-    const fromDb = await loadFromDb(lastSeen)
-    expect(evts.map(evtToDbRow)).toEqual(fromDb)
-
-    lastSeen = evts.at(-1)?.seq ?? lastSeen
-  })
-
-  it('buffers events that are not being read', async () => {
-    const count = 20
-    totalEvts += count
-    const outbox = new Outbox(sequencer)
-    const createPromise = createLabels(count)
-    const gen = outbox.events(lastSeen)
-    // read enough to start streaming then wait so that the rest go into the buffer,
-    // then stream out from buffer
-    const [firstPart] = await Promise.all([
-      readFromGenerator(gen, caughtUp(outbox), createPromise, 5),
-      createPromise,
-    ])
-    const secondPart = await readFromGenerator(
-      gen,
-      caughtUp(outbox),
-      createPromise,
-    )
-    const evts = [...firstPart, ...secondPart]
-    expect(evts.length).toBe(count)
-
-    const fromDb = await loadFromDb(lastSeen)
-    expect(evts.map(evtToDbRow)).toEqual(fromDb)
-
-    lastSeen = evts.at(-1)?.seq ?? lastSeen
-  })
-
-  it('errors when buffer is overloaded', async () => {
-    const count = 20
-    totalEvts += count
-    const outbox = new Outbox(sequencer, { maxBufferSize: 5 })
-    const gen = outbox.events(lastSeen)
-    const createPromise = createLabels(count)
-    // read enough to start streaming then wait to stream rest until buffer is overloaded
-    const overloadBuffer = async () => {
-      await Promise.all([
-        readFromGenerator(gen, caughtUp(outbox), createPromise, 5),
-        createPromise,
-      ])
-      await wait(500)
-      await readFromGenerator(gen, caughtUp(outbox), createPromise)
-    }
-    await expect(overloadBuffer).rejects.toThrow('Stream consumer too slow')
-
-    await createPromise
-
-    const fromDb = await loadFromDb(lastSeen)
-    lastSeen = fromDb.at(-1)?.id ?? lastSeen
-  })
-
-  it('handles many open connections', async () => {
-    const count = 20
-    const outboxes: Outbox[] = []
-    for (let i = 0; i < 50; i++) {
-      outboxes.push(new Outbox(sequencer))
-    }
-    const createPromise = createLabels(count)
-    const readOutboxes = Promise.all(
-      outboxes.map((o) =>
-        readFromGenerator(o.events(lastSeen), caughtUp(o), createPromise),
-      ),
-    )
-    const [results] = await Promise.all([readOutboxes, createPromise])
-    const fromDb = await loadFromDb(lastSeen)
-    for (const result of results) {
-      expect(result.length).toBe(count)
-      expect(result.map(evtToDbRow)).toEqual(fromDb)
-    }
-    lastSeen = results[0].at(-1)?.seq ?? lastSeen
-  })
-})

package/tests/server.test.ts

@@ -1,62 +0,0 @@
-import express from 'express'
-import { TestNetwork, TestOzone } from '@atproto/dev-env'
-import { handler as errorHandler } from '../src/error.js'
-import { startServer } from './_util.js'
-
-describe('server', () => {
-  let network: TestNetwork
-  let ozone: TestOzone
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_server',
-    })
-    ozone = network.ozone
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('preserves 404s.', async () => {
-    const response = await fetch(`${ozone.url}/unknown`)
-    expect(response.status).toEqual(404)
-  })
-
-  it('error handler turns unknown errors into 500s.', async () => {
-    const app = express()
-      .get('/oops', () => {
-        throw new Error('Oops!')
-      })
-      .use(errorHandler)
-
-    await using server = await startServer(app)
-
-    const response = await fetch(`http://localhost:${server.port}/oops`)
-    expect(response.status).toEqual(500)
-    await expect(response.json()).resolves.toEqual({
-      error: 'InternalServerError',
-      message: 'Internal Server Error',
-    })
-  })
-
-  it('healthcheck succeeds when database is available.', async () => {
-    const response = await fetch(`${network.bsky.url}/xrpc/_health`)
-    expect(response.status).toEqual(200)
-    await expect(response.json()).resolves.toEqual({ version: 'unknown' })
-  })
-
-  it('healthcheck fails when database is unavailable.', async () => {
-    // destroy sequencer to release connection that would prevent the db from closing
-    await ozone.ctx.sequencer.destroy()
-    await ozone.ctx.db.close()
-
-    const res = await fetch(`${ozone.url}/xrpc/_health`)
-
-    expect(res.status).toEqual(503)
-    await expect(res.json()).resolves.toEqual({
-      version: '0.0.0',
-      error: 'Service Unavailable',
-    })
-  })
-})