@atproto/ozone 0.2.9 → 0.2.11

package/tests/get-subjects.test.ts

@@ -1,81 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  TestOzone,
-  basicSeed,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import {
-  REASONOTHER,
-  REASONSPAM,
-} from '../src/lexicon/types/com/atproto/moderation/defs.js'
-import { forSnapshot } from './_util.js'
-
-describe('admin get multiple subjects with all relevant details', () => {
-  let network: TestNetwork
-  let ozone: TestOzone
-  let agent: AtpAgent
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_admin_get_subjects',
-    })
-    ozone = network.ozone
-    agent = ozone.getAgent()
-    sc = network.getSeedClient()
-    modClient = ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  beforeEach(async () => {
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  beforeAll(async () => {
-    await sc.createReport({
-      reportedBy: sc.dids.bob,
-      reasonType: REASONSPAM,
-      subject: {
-        $type: 'com.atproto.repo.strongRef',
-        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
-        cid: sc.posts[sc.dids.alice][0].ref.cidStr,
-      },
-    })
-    await sc.createReport({
-      reportedBy: sc.dids.carol,
-      reasonType: REASONOTHER,
-      reason: 'defamation',
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      },
-    })
-    await modClient.emitEvent({
-      event: { $type: 'tools.ozone.moderation.defs#modEventTakedown' },
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      },
-    })
-  })
-
-  it('gets multiple subjects with records', async () => {
-    const {
-      data: { subjects },
-    } = await agent.tools.ozone.moderation.getSubjects(
-      { subjects: [sc.dids.alice, sc.posts[sc.dids.alice][0].ref.uriStr] },
-      { headers: await ozone.modHeaders(ids.ToolsOzoneModerationGetSubjects) },
-    )
-
-    expect(forSnapshot(subjects)).toMatchSnapshot()
-  })
-})

package/tests/mod-tool.test.ts

@@ -1,268 +0,0 @@
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-
-describe('mod-tool tracking', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_mod_tool_test',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('stores and returns modTool with name and meta metadata', async () => {
-    const subject = {
-      $type: 'com.atproto.repo.strongRef' as const,
-      uri: sc.posts[sc.dids.bob][0].ref.uriStr,
-      cid: sc.posts[sc.dids.bob][0].ref.cidStr,
-    }
-
-    const modTool = {
-      name: 'automod/1.1.3',
-      meta: {
-        confidence: 85,
-        rules: ['high_risk_country', 'spam_detection'],
-        version: '1.1.3',
-        environment: 'production',
-      },
-    }
-
-    const emittedEvent = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['spam'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool,
-    })
-
-    expect(emittedEvent.modTool).toEqual(modTool)
-    expect(emittedEvent.modTool?.name).toBe('automod/1.1.3')
-    expect(emittedEvent.modTool?.meta).toEqual({
-      confidence: 85,
-      rules: ['high_risk_country', 'spam_detection'],
-      version: '1.1.3',
-      environment: 'production',
-    })
-
-    const queryResult = await modClient.queryEvents({
-      subject: subject.uri,
-    })
-
-    const foundEvent = queryResult.events.find((e) => e.id === emittedEvent.id)
-    expect(foundEvent?.modTool).toEqual(modTool)
-  })
-
-  it('filters events by modTool name', async () => {
-    const subject = {
-      $type: 'com.atproto.repo.strongRef' as const,
-      uri: sc.posts[sc.dids.alice][0].ref.uriStr,
-      cid: sc.posts[sc.dids.alice][0].ref.cidStr,
-    }
-
-    const event1 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['test1'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: { name: 'automod/1.1.3' },
-    })
-
-    const event2 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['test2'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: { name: 'ozone-web/1.0.0' },
-    })
-
-    const event3 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['test3'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: { name: 'mobile-app/2.1.0' },
-    })
-
-    const automodResults = await modClient.queryEvents({
-      subject: subject.uri,
-      modTool: ['automod/1.1.3'],
-    })
-
-    expect(automodResults.events).toHaveLength(1)
-    expect(automodResults.events[0].id).toBe(event1.id)
-    expect(automodResults.events[0].modTool?.name).toBe('automod/1.1.3')
-
-    const multipleResults = await modClient.queryEvents({
-      subject: subject.uri,
-      modTool: ['automod/1.1.3', 'ozone-web/1.0.0'],
-    })
-
-    expect(multipleResults.events).toHaveLength(2)
-    const eventIds = multipleResults.events.map((e) => e.id)
-    expect(eventIds).toContain(event1.id)
-    expect(eventIds).toContain(event2.id)
-    expect(eventIds).not.toContain(event3.id)
-  })
-
-  it('filters events by batchId and supports pagination', async () => {
-    const subject = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[sc.dids.carol][0].ref.uriStr,
-      cid: sc.posts[sc.dids.carol][0].ref.cidStr,
-    }
-
-    const batchId1 = 'batch-123'
-    const batchId2 = 'batch-456'
-
-    // Create events with first batchId
-    const event1 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['batch1-event1'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: {
-        name: 'automod/1.1.3',
-        meta: { batchId: batchId1 },
-      },
-    })
-
-    const event2 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['batch1-event2'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: {
-        name: 'automod/1.1.3',
-        meta: { batchId: batchId1 },
-      },
-    })
-
-    const event3 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['batch1-event3'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: {
-        name: 'ozone-ui/workspace',
-        meta: { batchId: batchId1 },
-      },
-    })
-
-    // Create events with second batchId
-    const event4 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['batch2-event1'],
-        negateLabelVals: [],
-      },
-      subject,
-      modTool: {
-        name: 'ozone-ui/workspace',
-        meta: { batchId: batchId2 },
-      },
-    })
-
-    // Create event without batchId
-    const event5 = await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventLabel',
-        createLabelVals: ['no-batch'],
-        negateLabelVals: [],
-      },
-      subject,
-    })
-
-    // Test filtering by first batchId
-    const batch1Results = await modClient.queryEvents({
-      subject: subject.uri,
-      batchId: batchId1,
-    })
-
-    expect(batch1Results.events).toHaveLength(3)
-    const batch1EventIds = batch1Results.events.map((e) => e.id)
-    expect(batch1EventIds).toContain(event1.id)
-    expect(batch1EventIds).toContain(event2.id)
-    expect(batch1EventIds).toContain(event3.id)
-    expect(batch1EventIds).not.toContain(event4.id)
-    expect(batch1EventIds).not.toContain(event5.id)
-
-    // Verify all events have the correct batchId
-    batch1Results.events.forEach((event) => {
-      expect(event.modTool?.meta?.batchId).toBe(batchId1)
-    })
-
-    // Test filtering by second batchId
-    const batch2Results = await modClient.queryEvents({
-      subject: subject.uri,
-      batchId: batchId2,
-    })
-
-    expect(batch2Results.events).toHaveLength(1)
-    expect(batch2Results.events[0].id).toBe(event4.id)
-    expect(batch2Results.events[0].modTool?.meta?.batchId).toBe(batchId2)
-
-    // Test pagination with batchId filter
-    const paginatedResults = await modClient.queryEvents({
-      subject: subject.uri,
-      batchId: batchId1,
-      limit: 2,
-    })
-
-    expect(paginatedResults.events).toHaveLength(2)
-    expect(paginatedResults.cursor).toBeTruthy()
-
-    // Get next page
-    const nextPageResults = await modClient.queryEvents({
-      subject: subject.uri,
-      batchId: batchId1,
-      limit: 2,
-      cursor: paginatedResults.cursor,
-    })
-
-    expect(nextPageResults.events).toHaveLength(1)
-
-    // Verify all paginated results have correct batchId
-    const allPaginatedEvents = paginatedResults.events.concat(
-      nextPageResults.events,
-    )
-    allPaginatedEvents.forEach((event) => {
-      expect(event.modTool?.meta?.batchId).toBe(batchId1)
-    })
-
-    // Verify we got all 3 events across pages
-    const allPaginatedIds = paginatedResults.events
-      .map((e) => e.id)
-      .concat(nextPageResults.events.map((e) => e.id))
-    expect(allPaginatedIds).toContain(event1.id)
-    expect(allPaginatedIds).toContain(event2.id)
-    expect(allPaginatedIds).toContain(event3.id)
-  })
-})

package/tests/moderation-appeals.test.ts

@@ -1,260 +0,0 @@
-import {
-  ComAtprotoModerationDefs,
-  ToolsOzoneModerationDefs,
-} from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import {
-  REASONMISLEADING,
-  REASONSPAM,
-} from '../src/lexicon/types/com/atproto/moderation/defs.js'
-import { REVIEWESCALATED } from '../src/lexicon/types/tools/ozone/moderation/defs.js'
-
-describe('moderation-appeals', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_moderation_appeals',
-    })
-    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,
-    appealed: boolean | undefined,
-  ): Promise<ToolsOzoneModerationDefs.SubjectStatusView | undefined> => {
-    const res = await modClient.queryStatuses({
-      subject,
-    })
-    expect(res.subjectStatuses[0]?.reviewState).toEqual(status)
-    expect(res.subjectStatuses[0]?.appealed).toEqual(appealed)
-    return res.subjectStatuses[0]
-  }
-
-  describe('appeals from users', () => {
-    const getBobsPostSubject = () => ({
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[sc.dids.bob][1].ref.uriStr,
-      cid: sc.posts[sc.dids.bob][1].ref.cidStr,
-    })
-    const getCarolPostSubject = () => ({
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[sc.dids.carol][0].ref.uriStr,
-      cid: sc.posts[sc.dids.carol][0].ref.cidStr,
-    })
-    const assertBobsPostStatus = async (
-      status: string,
-      appealed: boolean | undefined,
-    ) => assertSubjectStatus(getBobsPostSubject().uri, status, appealed)
-
-    it('only changes subject status if original author of the content or a moderator is appealing', async () => {
-      // Create a report by alice
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: REASONMISLEADING,
-        },
-        subject: getBobsPostSubject(),
-      })
-
-      await assertBobsPostStatus(ToolsOzoneModerationDefs.REVIEWOPEN, undefined)
-
-      // Create a report as normal user with appeal type
-      expect(
-        sc.createReport({
-          reportedBy: sc.dids.carol,
-          reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
-          reason: 'appealing',
-          subject: getBobsPostSubject(),
-        }),
-      ).rejects.toThrow('You cannot appeal this report')
-
-      // Verify that the appeal status did not change
-      await assertBobsPostStatus(ToolsOzoneModerationDefs.REVIEWOPEN, undefined)
-
-      // Emit report event as moderator
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: ComAtprotoModerationDefs.REASONAPPEAL,
-        },
-        subject: getBobsPostSubject(),
-      })
-
-      // Verify that appeal status changed when appeal report was emitted by moderator
-      const status = await assertBobsPostStatus(REVIEWESCALATED, true)
-      // @ts-expect-error unspecced ?
-      expect(status?.appealedAt).not.toBeNull()
-
-      // Create a report as normal user for carol's post
-      await sc.createReport({
-        reportedBy: sc.dids.alice,
-        reasonType: REASONMISLEADING,
-        reason: 'lies!',
-        subject: getCarolPostSubject(),
-      })
-
-      // Verify that the appeal status on carol's post is undefined
-      await assertSubjectStatus(
-        getCarolPostSubject().uri,
-        ToolsOzoneModerationDefs.REVIEWOPEN,
-        undefined,
-      )
-
-      await sc.createReport({
-        reportedBy: sc.dids.carol,
-        reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
-        reason: 'appealing',
-        subject: getCarolPostSubject(),
-      })
-      // Verify that the appeal status on carol's post is true
-      await assertSubjectStatus(
-        getCarolPostSubject().uri,
-        REVIEWESCALATED,
-        true,
-      )
-    })
-    it('allows multiple appeals and updates last appealed timestamp', async () => {
-      // Resolve appeal with acknowledge
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventResolveAppeal',
-        },
-        subject: getBobsPostSubject(),
-      })
-
-      const previousStatus = await assertBobsPostStatus(REVIEWESCALATED, false)
-
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: ComAtprotoModerationDefs.REASONAPPEAL,
-        },
-        subject: getBobsPostSubject(),
-      })
-
-      // Verify that even after the appeal event by bob for his post, the appeal status is true again with new timestamp
-      const newStatus = await assertBobsPostStatus(REVIEWESCALATED, true)
-      expect(
-        new Date(`${previousStatus?.lastAppealedAt}`).getTime(),
-      ).toBeLessThan(new Date(`${newStatus?.lastAppealedAt}`).getTime())
-    })
-  })
-
-  describe('appeal resolution', () => {
-    const getAlicesPostSubject = () => ({
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[sc.dids.alice][1].ref.uriStr,
-      cid: sc.posts[sc.dids.alice][1].ref.cidStr,
-    })
-    it('appeal status is maintained while review state changes based on incoming events', async () => {
-      // Bob reports alice's post
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: REASONMISLEADING,
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      // Moderator acknowledges the report, assume a label was applied too
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventAcknowledge',
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      // Alice appeals the report
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: ComAtprotoModerationDefs.REASONAPPEAL,
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      await assertSubjectStatus(
-        getAlicesPostSubject().uri,
-        REVIEWESCALATED,
-        true,
-      )
-
-      // Bob reports it again
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReport',
-          reportType: REASONSPAM,
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      // Assert that the status is still REVIEWESCALATED, as report events are meant to do
-      await assertSubjectStatus(
-        getAlicesPostSubject().uri,
-        REVIEWESCALATED,
-        true,
-      )
-
-      // Emit an escalation event
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventEscalate',
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      await assertSubjectStatus(
-        getAlicesPostSubject().uri,
-        REVIEWESCALATED,
-        true,
-      )
-
-      // Emit an acknowledge event
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventAcknowledge',
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      // Assert that status moved on to reviewClosed while appealed status is still true
-      await assertSubjectStatus(
-        getAlicesPostSubject().uri,
-        ToolsOzoneModerationDefs.REVIEWCLOSED,
-        true,
-      )
-
-      // Emit a resolveAppeal event
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventResolveAppeal',
-          comment: 'lgtm',
-        },
-        subject: getAlicesPostSubject(),
-      })
-
-      // Assert that status stayed the same while appealed status is still true
-      await assertSubjectStatus(
-        getAlicesPostSubject().uri,
-        ToolsOzoneModerationDefs.REVIEWCLOSED,
-        false,
-      )
-    })
-  })
-})