@atproto/ozone 0.0.2

package/tests/moderation-appeals.test.ts

@@ -0,0 +1,269 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent, {
+  ComAtprotoAdminDefs,
+  ComAtprotoAdminEmitModerationEvent,
+  ComAtprotoAdminQueryModerationStatuses,
+} from '@atproto/api'
+import {
+  REASONMISLEADING,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+import {
+  REVIEWCLOSED,
+  REVIEWOPEN,
+} from '@atproto/api/src/client/types/com/atproto/admin/defs'
+import { REASONAPPEAL } from '@atproto/api/src/client/types/com/atproto/moderation/defs'
+import { REVIEWESCALATED } from '../src/lexicon/types/com/atproto/admin/defs'
+
+describe('moderation-appeals', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let pdsAgent: AtpAgent
+  let sc: SeedClient
+
+  const emitModerationEvent = async (
+    eventData: ComAtprotoAdminEmitModerationEvent.InputSchema,
+  ) => {
+    return pdsAgent.api.com.atproto.admin.emitModerationEvent(eventData, {
+      encoding: 'application/json',
+      headers: network.ozone.adminAuthHeaders('moderator'),
+    })
+  }
+
+  const queryModerationStatuses = (
+    statusQuery: ComAtprotoAdminQueryModerationStatuses.QueryParams,
+  ) =>
+    agent.api.com.atproto.admin.queryModerationStatuses(statusQuery, {
+      headers: network.ozone.adminAuthHeaders('moderator'),
+    })
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_moderation_statuses',
+    })
+    agent = network.ozone.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  const assertSubjectStatus = async (
+    subject: string,
+    status: string,
+    appealed: boolean | undefined,
+  ): Promise<ComAtprotoAdminDefs.SubjectStatusView | undefined> => {
+    const { data } = await queryModerationStatuses({
+      subject,
+    })
+    expect(data.subjectStatuses[0]?.reviewState).toEqual(status)
+    expect(data.subjectStatuses[0]?.appealed).toEqual(appealed)
+    return data.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 emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONMISLEADING,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      await assertBobsPostStatus(REVIEWOPEN, undefined)
+
+      // Create a report as normal user with appeal type
+      expect(
+        sc.createReport({
+          reportedBy: sc.dids.carol,
+          reasonType: REASONAPPEAL,
+          reason: 'appealing',
+          subject: getBobsPostSubject(),
+        }),
+      ).rejects.toThrow('You cannot appeal this report')
+
+      // Verify that the appeal status did not change
+      await assertBobsPostStatus(REVIEWOPEN, undefined)
+
+      // Emit report event as moderator
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      // Verify that appeal status changed when appeal report was emitted by moderator
+      const status = await assertBobsPostStatus(REVIEWOPEN, true)
+      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,
+        REVIEWOPEN,
+        undefined,
+      )
+
+      await sc.createReport({
+        reportedBy: sc.dids.carol,
+        reasonType: REASONAPPEAL,
+        reason: 'appealing',
+        subject: getCarolPostSubject(),
+      })
+      // Verify that the appeal status on carol's post is true
+      await assertSubjectStatus(getCarolPostSubject().uri, REVIEWOPEN, true)
+    })
+    it('allows multiple appeals and updates last appealed timestamp', async () => {
+      // Resolve appeal with acknowledge
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventResolveAppeal',
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      const previousStatus = await assertBobsPostStatus(REVIEWOPEN, false)
+
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getBobsPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // 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(REVIEWOPEN, 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 emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONMISLEADING,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // Moderator acknowledges the report, assume a label was applied too
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventAcknowledge',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Alice appeals the report
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONAPPEAL,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.alice,
+      })
+
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWOPEN, true)
+
+      // Bob reports it again
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONSPAM,
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.bob,
+      })
+
+      // Assert that the status is still REVIEWOPEN, as report events are meant to do
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWOPEN, true)
+
+      // Emit an escalation event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventEscalate',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      await assertSubjectStatus(
+        getAlicesPostSubject().uri,
+        REVIEWESCALATED,
+        true,
+      )
+
+      // Emit an acknowledge event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventAcknowledge',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Assert that status moved on to reviewClosed while appealed status is still true
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWCLOSED, true)
+
+      // Emit a resolveAppeal event
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventResolveAppeal',
+          comment: 'lgtm',
+        },
+        subject: getAlicesPostSubject(),
+        createdBy: sc.dids.carol,
+      })
+
+      // Assert that status stayed the same while appealed status is still true
+      await assertSubjectStatus(getAlicesPostSubject().uri, REVIEWCLOSED, false)
+    })
+  })
+})

package/tests/moderation-events.test.ts

@@ -0,0 +1,220 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent, { ComAtprotoAdminDefs } from '@atproto/api'
+import { forSnapshot } from './_util'
+import {
+  REASONMISLEADING,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+
+describe('moderation-events', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let pdsAgent: AtpAgent
+  let sc: SeedClient
+
+  const emitModerationEvent = async (eventData) => {
+    return pdsAgent.api.com.atproto.admin.emitModerationEvent(eventData, {
+      encoding: 'application/json',
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+  }
+
+  const queryModerationEvents = (eventQuery) =>
+    agent.api.com.atproto.admin.queryModerationEvents(eventQuery, {
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+
+  const seedEvents = async () => {
+    const bobsAccount = {
+      $type: 'com.atproto.admin.defs#repoRef',
+      did: sc.dids.bob,
+    }
+    const alicesAccount = {
+      $type: 'com.atproto.admin.defs#repoRef',
+      did: sc.dids.alice,
+    }
+    const bobsPost = {
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.bob][0].ref.uriStr,
+      cid: sc.posts[sc.dids.bob][0].ref.cidStr,
+    }
+    const alicesPost = {
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+      cid: sc.posts[sc.dids.alice][0].ref.cidStr,
+    }
+
+    for (let i = 0; i < 4; i++) {
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: i % 2 ? REASONSPAM : REASONMISLEADING,
+          comment: 'X',
+        },
+        //   Report bob's account by alice and vice versa
+        subject: i % 2 ? bobsAccount : alicesAccount,
+        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+      })
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONSPAM,
+          comment: 'X',
+        },
+        //   Report bob's post by alice and vice versa
+        subject: i % 2 ? bobsPost : alicesPost,
+        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+      })
+    }
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_moderation_events',
+    })
+    agent = network.ozone.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+    await seedEvents()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('query events', () => {
+    it('returns all events for record or repo', async () => {
+      const [bobsEvents, alicesPostEvents] = await Promise.all([
+        queryModerationEvents({
+          subject: sc.dids.bob,
+        }),
+        queryModerationEvents({
+          subject: sc.posts[sc.dids.alice][0].ref.uriStr,
+        }),
+      ])
+
+      expect(forSnapshot(bobsEvents.data.events)).toMatchSnapshot()
+      expect(forSnapshot(alicesPostEvents.data.events)).toMatchSnapshot()
+    })
+
+    it('filters events by types', async () => {
+      const alicesAccount = {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      }
+      await Promise.all([
+        emitModerationEvent({
+          event: {
+            $type: 'com.atproto.admin.defs#modEventComment',
+            comment: 'X',
+          },
+          subject: alicesAccount,
+          createdBy: 'did:plc:moderator',
+        }),
+        emitModerationEvent({
+          event: {
+            $type: 'com.atproto.admin.defs#modEventEscalate',
+            comment: 'X',
+          },
+          subject: alicesAccount,
+          createdBy: 'did:plc:moderator',
+        }),
+      ])
+      const [allEvents, reportEvents] = await Promise.all([
+        queryModerationEvents({
+          subject: sc.dids.alice,
+        }),
+        queryModerationEvents({
+          subject: sc.dids.alice,
+          types: ['com.atproto.admin.defs#modEventReport'],
+        }),
+      ])
+
+      expect(allEvents.data.events.length).toBeGreaterThan(
+        reportEvents.data.events.length,
+      )
+      expect(
+        [...new Set(reportEvents.data.events.map((e) => e.event.$type))].length,
+      ).toEqual(1)
+
+      expect(
+        [...new Set(allEvents.data.events.map((e) => e.event.$type))].length,
+      ).toEqual(3)
+    })
+
+    it('returns events for all content by user', async () => {
+      const [forAccount, forPost] = await Promise.all([
+        queryModerationEvents({
+          subject: sc.dids.bob,
+          includeAllUserRecords: true,
+        }),
+        queryModerationEvents({
+          subject: sc.posts[sc.dids.bob][0].ref.uriStr,
+          includeAllUserRecords: true,
+        }),
+      ])
+
+      expect(forAccount.data.events.length).toEqual(forPost.data.events.length)
+      // Save events are returned from both requests
+      expect(forPost.data.events.map(({ id }) => id).sort()).toEqual(
+        forAccount.data.events.map(({ id }) => id).sort(),
+      )
+    })
+
+    it('returns paginated list of events with cursor', async () => {
+      const allEvents = await queryModerationEvents({
+        subject: sc.dids.bob,
+        includeAllUserRecords: true,
+      })
+
+      const getPaginatedEvents = async (
+        sortDirection: 'asc' | 'desc' = 'desc',
+      ) => {
+        let defaultCursor: undefined | string = undefined
+        const events: ComAtprotoAdminDefs.ModEventView[] = []
+        let count = 0
+        do {
+          // get 1 event at a time and check we get all events
+          const { data } = await queryModerationEvents({
+            limit: 1,
+            subject: sc.dids.bob,
+            includeAllUserRecords: true,
+            cursor: defaultCursor,
+            sortDirection,
+          })
+          events.push(...data.events)
+          defaultCursor = data.cursor
+          count++
+          // The count is a circuit breaker to prevent infinite loop in case of failing test
+        } while (defaultCursor && count < 10)
+
+        return events
+      }
+
+      const defaultEvents = await getPaginatedEvents()
+      const reversedEvents = await getPaginatedEvents('asc')
+
+      expect(allEvents.data.events.length).toEqual(5)
+      expect(defaultEvents.length).toEqual(allEvents.data.events.length)
+      expect(reversedEvents.length).toEqual(allEvents.data.events.length)
+      expect(reversedEvents[0].id).toEqual(defaultEvents[4].id)
+    })
+  })
+
+  describe('get event', () => {
+    it('gets an event by specific id', async () => {
+      const { data } = await pdsAgent.api.com.atproto.admin.getModerationEvent(
+        {
+          id: 1,
+        },
+        {
+          headers: network.bsky.adminAuthHeaders('moderator'),
+        },
+      )
+
+      expect(forSnapshot(data)).toMatchSnapshot()
+    })
+  })
+})

package/tests/moderation-statuses.test.ts

@@ -0,0 +1,144 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent, {
+  ComAtprotoAdminDefs,
+  ComAtprotoAdminQueryModerationStatuses,
+} from '@atproto/api'
+import { forSnapshot } from './_util'
+import {
+  REASONMISLEADING,
+  REASONSPAM,
+} from '../src/lexicon/types/com/atproto/moderation/defs'
+
+describe('moderation-statuses', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let pdsAgent: AtpAgent
+  let sc: SeedClient
+
+  const emitModerationEvent = async (eventData) => {
+    return pdsAgent.api.com.atproto.admin.emitModerationEvent(eventData, {
+      encoding: 'application/json',
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+  }
+
+  const queryModerationStatuses = (statusQuery) =>
+    agent.api.com.atproto.admin.queryModerationStatuses(statusQuery, {
+      headers: network.bsky.adminAuthHeaders('moderator'),
+    })
+
+  const seedEvents = async () => {
+    const bobsAccount = {
+      $type: 'com.atproto.admin.defs#repoRef',
+      did: sc.dids.bob,
+    }
+    const carlasAccount = {
+      $type: 'com.atproto.admin.defs#repoRef',
+      did: sc.dids.alice,
+    }
+    const bobsPost = {
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.bob][1].ref.uriStr,
+      cid: sc.posts[sc.dids.bob][1].ref.cidStr,
+    }
+    const alicesPost = {
+      $type: 'com.atproto.repo.strongRef',
+      uri: sc.posts[sc.dids.alice][1].ref.uriStr,
+      cid: sc.posts[sc.dids.alice][1].ref.cidStr,
+    }
+
+    for (let i = 0; i < 4; i++) {
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: i % 2 ? REASONSPAM : REASONMISLEADING,
+          comment: 'X',
+        },
+        //   Report bob's account by alice and vice versa
+        subject: i % 2 ? bobsAccount : carlasAccount,
+        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+      })
+      await emitModerationEvent({
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          reportType: REASONSPAM,
+          comment: 'X',
+        },
+        //   Report bob's post by alice and vice versa
+        subject: i % 2 ? bobsPost : alicesPost,
+        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+      })
+    }
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_moderation_statuses',
+    })
+    agent = network.ozone.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+    await seedEvents()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('query statuses', () => {
+    it('returns statuses for subjects that received moderation events', async () => {
+      const response = await queryModerationStatuses({})
+
+      expect(forSnapshot(response.data.subjectStatuses)).toMatchSnapshot()
+    })
+
+    it('returns paginated statuses', async () => {
+      // We know there will be exactly 4 statuses in db
+      const getPaginatedStatuses = async (
+        params: ComAtprotoAdminQueryModerationStatuses.QueryParams,
+      ) => {
+        let cursor: string | undefined = ''
+        const statuses: ComAtprotoAdminDefs.SubjectStatusView[] = []
+        let count = 0
+        do {
+          const results = await queryModerationStatuses({
+            limit: 1,
+            cursor,
+            ...params,
+          })
+          cursor = results.data.cursor
+          statuses.push(...results.data.subjectStatuses)
+          count++
+          // The count is just a brake-check to prevent infinite loop
+        } while (cursor && count < 10)
+
+        return statuses
+      }
+
+      const list = await getPaginatedStatuses({})
+      expect(list[0].id).toEqual(4)
+      expect(list[list.length - 1].id).toEqual(1)
+
+      await emitModerationEvent({
+        subject: list[1].subject,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventAcknowledge',
+          comment: 'X',
+        },
+        createdBy: sc.dids.bob,
+      })
+
+      const listReviewedFirst = await getPaginatedStatuses({
+        sortDirection: 'desc',
+        sortField: 'lastReviewedAt',
+      })
+
+      // Verify that the item that was recently reviewed comes up first when sorted descendingly
+      // while the result set always contains same number of items regardless of sorting
+      expect(listReviewedFirst[0].id).toEqual(list[1].id)
+      expect(listReviewedFirst.length).toEqual(list.length)
+    })
+  })
+})