@atproto/ozone 0.0.16 → 0.0.17-next.1

package/tests/moderation-events.test.ts

@@ -1,11 +1,13 @@
 import assert from 'node:assert'
 import EventEmitter, { once } from 'node:events'
+import {
+  TestNetwork,
+  SeedClient,
+  basicSeed,
+  ModeratorClient,
+} from '@atproto/dev-env'
+import { ToolsOzoneModerationDefs } from '@atproto/api'
 import Mail from 'nodemailer/lib/mailer'
-import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import AtpAgent, {
-  ComAtprotoAdminDefs,
-  ComAtprotoAdminEmitModerationEvent,
-} from '@atproto/api'
 import { forSnapshot } from './_util'
 import {
   REASONAPPEAL,
@@ -15,23 +17,8 @@ import {
 
 describe('moderation-events', () => {
   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 queryModerationEvents = (eventQuery) =>
-    agent.api.com.atproto.admin.queryModerationEvents(eventQuery, {
-      headers: network.ozone.adminAuthHeaders('moderator'),
-    })
+  let modClient: ModeratorClient
 
   const seedEvents = async () => {
     const bobsAccount = {
@@ -54,25 +41,19 @@ describe('moderation-events', () => {
     }
 
     for (let i = 0; i < 4; i++) {
-      await emitModerationEvent({
-        event: {
-          $type: 'com.atproto.admin.defs#modEventReport',
-          reportType: i % 2 ? REASONSPAM : REASONMISLEADING,
-          comment: 'X',
-        },
+      await sc.createReport({
+        reasonType: i % 2 ? REASONSPAM : REASONMISLEADING,
+        reason: 'X',
         //   Report bob's account by alice and vice versa
         subject: i % 2 ? bobsAccount : alicesAccount,
-        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+        reportedBy: i % 2 ? sc.dids.alice : sc.dids.bob,
       })
-      await emitModerationEvent({
-        event: {
-          $type: 'com.atproto.admin.defs#modEventReport',
-          reportType: REASONSPAM,
-          comment: 'X',
-        },
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'X',
         //   Report bob's post by alice and vice versa
         subject: i % 2 ? bobsPost : alicesPost,
-        createdBy: i % 2 ? sc.dids.alice : sc.dids.bob,
+        reportedBy: i % 2 ? sc.dids.alice : sc.dids.bob,
       })
     }
   }
@@ -81,9 +62,8 @@ describe('moderation-events', () => {
     network = await TestNetwork.create({
       dbPostgresSchema: 'ozone_moderation_events',
     })
-    agent = network.ozone.getClient()
-    pdsAgent = network.pds.getClient()
     sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
     await basicSeed(sc)
     await network.processAll()
     await seedEvents()
@@ -96,16 +76,16 @@ describe('moderation-events', () => {
   describe('query events', () => {
     it('returns all events for record or repo', async () => {
       const [bobsEvents, alicesPostEvents] = await Promise.all([
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.dids.bob,
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.posts[sc.dids.alice][0].ref.uriStr,
         }),
       ])
 
-      expect(forSnapshot(bobsEvents.data.events)).toMatchSnapshot()
-      expect(forSnapshot(alicesPostEvents.data.events)).toMatchSnapshot()
+      expect(forSnapshot(bobsEvents.events)).toMatchSnapshot()
+      expect(forSnapshot(alicesPostEvents.events)).toMatchSnapshot()
     })
 
     it('filters events by types', async () => {
@@ -114,66 +94,64 @@ describe('moderation-events', () => {
         did: sc.dids.alice,
       }
       await Promise.all([
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventComment',
+            $type: 'tools.ozone.moderation.defs#modEventComment',
             comment: 'X',
           },
           subject: alicesAccount,
-          createdBy: 'did:plc:moderator',
         }),
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventEscalate',
+            $type: 'tools.ozone.moderation.defs#modEventEscalate',
             comment: 'X',
           },
           subject: alicesAccount,
-          createdBy: 'did:plc:moderator',
         }),
       ])
       const [allEvents, reportEvents] = await Promise.all([
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.dids.alice,
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.dids.alice,
-          types: ['com.atproto.admin.defs#modEventReport'],
+          types: ['tools.ozone.moderation.defs#modEventReport'],
         }),
       ])
 
-      expect(allEvents.data.events.length).toBeGreaterThan(
-        reportEvents.data.events.length,
+      expect(allEvents.events.length).toBeGreaterThan(
+        reportEvents.events.length,
       )
       expect(
-        [...new Set(reportEvents.data.events.map((e) => e.event.$type))].length,
+        [...new Set(reportEvents.events.map((e) => e.event.$type))].length,
       ).toEqual(1)
 
       expect(
-        [...new Set(allEvents.data.events.map((e) => e.event.$type))].length,
+        [...new Set(allEvents.events.map((e) => e.event.$type))].length,
       ).toEqual(4)
     })
 
     it('returns events for all content by user', async () => {
       const [forAccount, forPost] = await Promise.all([
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.dids.bob,
           includeAllUserRecords: true,
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           subject: sc.posts[sc.dids.bob][0].ref.uriStr,
           includeAllUserRecords: true,
         }),
       ])
 
-      expect(forAccount.data.events.length).toEqual(forPost.data.events.length)
+      expect(forAccount.events.length).toEqual(forPost.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(),
+      expect(forPost.events.map(({ id }) => id).sort()).toEqual(
+        forAccount.events.map(({ id }) => id).sort(),
       )
     })
 
     it('returns paginated list of events with cursor', async () => {
-      const allEvents = await queryModerationEvents({
+      const allEvents = await modClient.queryEvents({
         subject: sc.dids.bob,
         includeAllUserRecords: true,
       })
@@ -182,19 +160,19 @@ describe('moderation-events', () => {
         sortDirection: 'asc' | 'desc' = 'desc',
       ) => {
         let defaultCursor: undefined | string = undefined
-        const events: ComAtprotoAdminDefs.ModEventView[] = []
+        const events: ToolsOzoneModerationDefs.ModEventView[] = []
         let count = 0
         do {
           // get 1 event at a time and check we get all events
-          const { data } = await queryModerationEvents({
+          const res = await modClient.queryEvents({
             limit: 1,
             subject: sc.dids.bob,
             includeAllUserRecords: true,
             cursor: defaultCursor,
             sortDirection,
           })
-          events.push(...data.events)
-          defaultCursor = data.cursor
+          events.push(...res.events)
+          defaultCursor = res.cursor
           count++
           // The count is a circuit breaker to prevent infinite loop in case of failing test
         } while (defaultCursor && count < 10)
@@ -205,51 +183,53 @@ describe('moderation-events', () => {
       const defaultEvents = await getPaginatedEvents()
       const reversedEvents = await getPaginatedEvents('asc')
 
-      expect(allEvents.data.events.length).toEqual(6)
-      expect(defaultEvents.length).toEqual(allEvents.data.events.length)
-      expect(reversedEvents.length).toEqual(allEvents.data.events.length)
+      expect(allEvents.events.length).toEqual(6)
+      expect(defaultEvents.length).toEqual(allEvents.events.length)
+      expect(reversedEvents.length).toEqual(allEvents.events.length)
       // First event in the reversed list is the last item in the default list
-      expect(reversedEvents[0].id).toEqual(defaultEvents[5].id)
+      expect(reversedEvents[0].id).toEqual(
+        defaultEvents[defaultEvents.length - 1].id,
+      )
     })
 
     it('returns report events matching reportType filters', async () => {
       const [spamEvents, misleadingEvents] = await Promise.all([
-        queryModerationEvents({
+        modClient.queryEvents({
           reportTypes: [REASONSPAM],
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           reportTypes: [REASONMISLEADING, REASONAPPEAL],
         }),
       ])
 
-      expect(misleadingEvents.data.events.length).toEqual(2)
-      expect(spamEvents.data.events.length).toEqual(6)
+      expect(misleadingEvents.events.length).toEqual(2)
+      expect(spamEvents.events.length).toEqual(6)
     })
 
     it('returns events matching keyword in comment', async () => {
       const [eventsWithX, eventsWithTest, eventsWithComment] =
         await Promise.all([
-          queryModerationEvents({
+          modClient.queryEvents({
             comment: 'X',
           }),
-          queryModerationEvents({
+          modClient.queryEvents({
             comment: 'test',
           }),
-          queryModerationEvents({
+          modClient.queryEvents({
             hasComment: true,
           }),
         ])
 
-      expect(eventsWithX.data.events.length).toEqual(10)
-      expect(eventsWithTest.data.events.length).toEqual(0)
-      expect(eventsWithComment.data.events.length).toEqual(10)
+      expect(eventsWithX.events.length).toEqual(10)
+      expect(eventsWithTest.events.length).toEqual(0)
+      expect(eventsWithComment.events.length).toEqual(10)
     })
 
     it('returns events matching filter params for labels', async () => {
       const [negatedLabelEvent, createdLabelEvent] = await Promise.all([
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventLabel',
+            $type: 'tools.ozone.moderation.defs#modEventLabel',
             comment: 'X',
             negateLabelVals: ['L1', 'L2'],
             createLabelVals: [],
@@ -259,11 +239,10 @@ describe('moderation-events', () => {
             $type: 'com.atproto.admin.defs#repoRef',
             did: sc.dids.alice,
           },
-          createdBy: sc.dids.bob,
         }),
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventLabel',
+            $type: 'tools.ozone.moderation.defs#modEventLabel',
             comment: 'X',
             createLabelVals: ['L1', 'L2'],
             negateLabelVals: [],
@@ -273,36 +252,31 @@ describe('moderation-events', () => {
             $type: 'com.atproto.admin.defs#repoRef',
             did: sc.dids.bob,
           },
-          createdBy: sc.dids.alice,
         }),
       ])
       const [withTwoLabels, withoutTwoLabels, withOneLabel, withoutOneLabel] =
         await Promise.all([
-          queryModerationEvents({
+          modClient.queryEvents({
             addedLabels: ['L1', 'L3'],
           }),
-          queryModerationEvents({
+          modClient.queryEvents({
             removedLabels: ['L1', 'L2'],
           }),
-          queryModerationEvents({
+          modClient.queryEvents({
             addedLabels: ['L1'],
           }),
-          queryModerationEvents({
+          modClient.queryEvents({
             removedLabels: ['L2'],
           }),
         ])
 
       // Verify that when querying for events where 2 different labels were added
       // events where all of the labels from the list was added are returned
-      expect(withTwoLabels.data.events.length).toEqual(0)
-      expect(negatedLabelEvent.data.id).toEqual(
-        withoutTwoLabels.data.events[0].id,
-      )
+      expect(withTwoLabels.events.length).toEqual(0)
+      expect(negatedLabelEvent.id).toEqual(withoutTwoLabels.events[0].id)
 
-      expect(createdLabelEvent.data.id).toEqual(withOneLabel.data.events[0].id)
-      expect(negatedLabelEvent.data.id).toEqual(
-        withoutOneLabel.data.events[0].id,
-      )
+      expect(createdLabelEvent.id).toEqual(withOneLabel.events[0].id)
+      expect(negatedLabelEvent.id).toEqual(withoutOneLabel.events[0].id)
     })
     it('returns events matching filter params for tags', async () => {
       const tagEvent = async ({
@@ -312,9 +286,9 @@ describe('moderation-events', () => {
         add: string[]
         remove: string[]
       }) =>
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventTag',
+            $type: 'tools.ozone.moderation.defs#modEventTag',
             comment: 'X',
             add,
             remove,
@@ -323,43 +297,35 @@ describe('moderation-events', () => {
             $type: 'com.atproto.admin.defs#repoRef',
             did: sc.dids.carol,
           },
-          createdBy: sc.dids.bob,
         })
       const addEvent = await tagEvent({ add: ['L1', 'L2'], remove: [] })
       const addAndRemoveEvent = await tagEvent({ add: ['L3'], remove: ['L2'] })
       const [addFinder, addAndRemoveFinder, _removeFinder] = await Promise.all([
-        queryModerationEvents({
+        modClient.queryEvents({
           addedTags: ['L1'],
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           addedTags: ['L3'],
           removedTags: ['L2'],
         }),
-        queryModerationEvents({
+        modClient.queryEvents({
           removedTags: ['L2'],
         }),
       ])
 
-      expect(addFinder.data.events.length).toEqual(1)
-      expect(addEvent.data.id).toEqual(addFinder.data.events[0].id)
+      expect(addFinder.events.length).toEqual(1)
+      expect(addEvent.id).toEqual(addFinder.events[0].id)
 
-      expect(addAndRemoveEvent.data.id).toEqual(
-        addAndRemoveFinder.data.events[0].id,
-      )
-      expect(addAndRemoveEvent.data.id).toEqual(
-        addAndRemoveFinder.data.events[0].id,
-      )
-      expect(addAndRemoveEvent.data.event.add).toEqual(['L3'])
-      expect(addAndRemoveEvent.data.event.remove).toEqual(['L2'])
+      expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
+      expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
+      expect(addAndRemoveEvent.event.add).toEqual(['L3'])
+      expect(addAndRemoveEvent.event.remove).toEqual(['L2'])
     })
   })
 
   describe('get event', () => {
     it('gets an event by specific id', async () => {
-      const { data } = await pdsAgent.api.com.atproto.admin.getModerationEvent(
-        { id: 1 },
-        { headers: network.ozone.adminAuthHeaders('moderator') },
-      )
+      const data = await modClient.getEvent(1)
       expect(forSnapshot(data)).toMatchSnapshot()
     })
   })
@@ -368,9 +334,9 @@ describe('moderation-events', () => {
     it('are tracked on takedown event', async () => {
       const post = sc.posts[sc.dids.carol][0]
       assert(post.images.length > 1)
-      await emitModerationEvent({
+      await modClient.emitEvent({
         event: {
-          $type: 'com.atproto.admin.defs#modEventTakedown',
+          $type: 'tools.ozone.moderation.defs#modEventTakedown',
         },
         subject: {
           $type: 'com.atproto.repo.strongRef',
@@ -378,20 +344,15 @@ describe('moderation-events', () => {
           cid: post.ref.cidStr,
         },
         subjectBlobCids: [post.images[0].image.ref.toString()],
-        createdBy: sc.dids.alice,
       })
-      const { data: result } =
-        await pdsAgent.api.com.atproto.admin.queryModerationEvents(
-          {
-            subject: post.ref.uriStr,
-            types: ['com.atproto.admin.defs#modEventTakedown'],
-          },
-          { headers: network.ozone.adminAuthHeaders('moderator') },
-        )
+      const result = await modClient.queryEvents({
+        subject: post.ref.uriStr,
+        types: ['tools.ozone.moderation.defs#modEventTakedown'],
+      })
       expect(result.events[0]).toMatchObject({
-        createdBy: sc.dids.alice,
+        createdBy: network.ozone.moderatorAccnt.did,
         event: {
-          $type: 'com.atproto.admin.defs#modEventTakedown',
+          $type: 'tools.ozone.moderation.defs#modEventTakedown',
         },
         subjectBlobCids: [post.images[0].image.ref.toString()],
       })
@@ -399,26 +360,23 @@ describe('moderation-events', () => {
 
     it("are tracked on reverse-takedown event even if they aren't specified", async () => {
       const post = sc.posts[sc.dids.carol][0]
-      await emitModerationEvent({
+      await modClient.emitEvent({
         event: {
-          $type: 'com.atproto.admin.defs#modEventReverseTakedown',
+          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
         },
         subject: {
           $type: 'com.atproto.repo.strongRef',
           uri: post.ref.uriStr,
           cid: post.ref.cidStr,
         },
-        createdBy: sc.dids.alice,
       })
-      const { data: result } =
-        await pdsAgent.api.com.atproto.admin.queryModerationEvents(
-          { subject: post.ref.uriStr },
-          { headers: network.ozone.adminAuthHeaders('moderator') },
-        )
+      const result = await modClient.queryEvents({
+        subject: post.ref.uriStr,
+      })
       expect(result.events[0]).toMatchObject({
-        createdBy: sc.dids.alice,
+        createdBy: network.ozone.moderatorAccnt.did,
         event: {
-          $type: 'com.atproto.admin.defs#modEventReverseTakedown',
+          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
         },
         subjectBlobCids: [post.images[0].image.ref.toString()],
       })
@@ -450,9 +408,9 @@ describe('moderation-events', () => {
 
     it('sends email via pds.', async () => {
       const mail = await getMailFrom(
-        emitModerationEvent({
+        modClient.emitEvent({
           event: {
-            $type: 'com.atproto.admin.defs#modEventEmail',
+            $type: 'tools.ozone.moderation.defs#modEventEmail',
             comment: 'Reaching out to Alice',
             subjectLine: 'Hello',
             content: 'Hey Alice, how are you?',
@@ -461,7 +419,6 @@ describe('moderation-events', () => {
             $type: 'com.atproto.admin.defs#repoRef',
             did: sc.dids.alice,
           },
-          createdBy: sc.dids.bob,
         }),
       )
       expect(mail).toEqual({

package/tests/moderation-status-tags.test.ts

@@ -1,32 +1,22 @@
-import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import AtpAgent from '@atproto/api'
+import {
+  TestNetwork,
+  SeedClient,
+  basicSeed,
+  ModeratorClient,
+} from '@atproto/dev-env'
 import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs'
 
 describe('moderation-status-tags', () => {
   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'),
-    })
+  let modClient: ModeratorClient
 
   beforeAll(async () => {
     network = await TestNetwork.create({
       dbPostgresSchema: 'ozone_moderation_status_tags',
     })
-    agent = network.ozone.getClient()
-    pdsAgent = network.pds.getClient()
     sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
     await basicSeed(sc)
     await network.processAll()
   })
@@ -41,43 +31,36 @@ describe('moderation-status-tags', () => {
         $type: 'com.atproto.admin.defs#repoRef',
         did: sc.dids.bob,
       }
-      await emitModerationEvent({
+      await sc.createReport({
+        reasonType: REASONSPAM,
+        reason: 'X',
         subject: bobsAccount,
-        event: {
-          $type: 'com.atproto.admin.defs#modEventReport',
-          comment: 'X',
-          reportType: REASONSPAM,
-        },
-        createdBy: sc.dids.alice,
+        reportedBy: sc.dids.alice,
       })
-      await emitModerationEvent({
+      await modClient.emitEvent({
         subject: bobsAccount,
         event: {
-          $type: 'com.atproto.admin.defs#modEventTag',
+          $type: 'tools.ozone.moderation.defs#modEventTag',
           add: ['interaction-churn'],
           remove: [],
         },
-        createdBy: sc.dids.alice,
       })
-      const { data: statusAfterInteractionTag } = await queryModerationStatuses(
-        {
-          subject: bobsAccount.did,
-        },
-      )
+      const statusAfterInteractionTag = await modClient.queryStatuses({
+        subject: bobsAccount.did,
+      })
       expect(statusAfterInteractionTag.subjectStatuses[0].tags).toContain(
         'interaction-churn',
       )
 
-      await emitModerationEvent({
+      await modClient.emitEvent({
         subject: bobsAccount,
         event: {
-          $type: 'com.atproto.admin.defs#modEventTag',
+          $type: 'tools.ozone.moderation.defs#modEventTag',
           remove: ['interaction-churn'],
           add: ['follow-churn'],
         },
-        createdBy: sc.dids.alice,
       })
-      const { data: statusAfterFollowTag } = await queryModerationStatuses({
+      const statusAfterFollowTag = await modClient.queryStatuses({
         subject: bobsAccount.did,
       })