@atproto/ozone 0.0.8 → 0.0.10

package/tests/moderation-events.test.ts

@@ -148,7 +148,7 @@ describe('moderation-events', () => {
 
       expect(
         [...new Set(allEvents.data.events.map((e) => e.event.$type))].length,
-      ).toEqual(3)
+      ).toEqual(4)
     })
 
     it('returns events for all content by user', async () => {
@@ -203,10 +203,11 @@ describe('moderation-events', () => {
       const defaultEvents = await getPaginatedEvents()
       const reversedEvents = await getPaginatedEvents('asc')
 
-      expect(allEvents.data.events.length).toEqual(5)
+      expect(allEvents.data.events.length).toEqual(7)
       expect(defaultEvents.length).toEqual(allEvents.data.events.length)
       expect(reversedEvents.length).toEqual(allEvents.data.events.length)
-      expect(reversedEvents[0].id).toEqual(defaultEvents[4].id)
+      // First event in the reversed list is the last item in the default list
+      expect(reversedEvents[0].id).toEqual(defaultEvents[6].id)
     })
 
     it('returns report events matching reportType filters', async () => {
@@ -242,7 +243,7 @@ describe('moderation-events', () => {
       expect(eventsWithComment.data.events.length).toEqual(12)
     })
 
-    it('returns events matching filter params for columns', async () => {
+    it('returns events matching filter params for labels', async () => {
       const [negatedLabelEvent, createdLabelEvent] = await Promise.all([
         emitModerationEvent({
           event: {
@@ -301,6 +302,54 @@ describe('moderation-events', () => {
         withoutOneLabel.data.events[0].id,
       )
     })
+    it('returns events matching filter params for tags', async () => {
+      const tagEvent = async ({
+        add,
+        remove,
+      }: {
+        add: string[]
+        remove: string[]
+      }) =>
+        emitModerationEvent({
+          event: {
+            $type: 'com.atproto.admin.defs#modEventTag',
+            comment: 'X',
+            add,
+            remove,
+          },
+          subject: {
+            $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({
+          addedTags: ['L1'],
+        }),
+        queryModerationEvents({
+          addedTags: ['L3'],
+          removedTags: ['L2'],
+        }),
+        queryModerationEvents({
+          removedTags: ['L2'],
+        }),
+      ])
+
+      expect(addFinder.data.events.length).toEqual(1)
+      expect(addEvent.data.id).toEqual(addFinder.data.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'])
+    })
   })
 
   describe('get event', () => {
@@ -331,7 +380,10 @@ describe('moderation-events', () => {
       })
       const { data: result } =
         await pdsAgent.api.com.atproto.admin.queryModerationEvents(
-          { subject: post.ref.uriStr },
+          {
+            subject: post.ref.uriStr,
+            types: ['com.atproto.admin.defs#modEventTakedown'],
+          },
           { headers: network.ozone.adminAuthHeaders('moderator') },
         )
       expect(result.events[0]).toMatchObject({

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

@@ -0,0 +1,92 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent from '@atproto/api'
+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'),
+    })
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_moderation_status_tags',
+    })
+    agent = network.ozone.getClient()
+    pdsAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('manage tags on subject status', () => {
+    it('adds and removes tags on a subject', async () => {
+      const bobsAccount = {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.bob,
+      }
+      await emitModerationEvent({
+        subject: bobsAccount,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventReport',
+          comment: 'X',
+          reportType: REASONSPAM,
+        },
+        createdBy: sc.dids.alice,
+      })
+      await emitModerationEvent({
+        subject: bobsAccount,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventTag',
+          add: ['interaction-churn'],
+          remove: [],
+        },
+        createdBy: sc.dids.alice,
+      })
+      const { data: statusAfterInteractionTag } = await queryModerationStatuses(
+        {
+          subject: bobsAccount.did,
+        },
+      )
+      expect(statusAfterInteractionTag.subjectStatuses[0].tags).toContain(
+        'interaction-churn',
+      )
+
+      await emitModerationEvent({
+        subject: bobsAccount,
+        event: {
+          $type: 'com.atproto.admin.defs#modEventTag',
+          remove: ['interaction-churn'],
+          add: ['follow-churn'],
+        },
+        createdBy: sc.dids.alice,
+      })
+      const { data: statusAfterFollowTag } = await queryModerationStatuses({
+        subject: bobsAccount.did,
+      })
+
+      expect(statusAfterFollowTag.subjectStatuses[0].tags).not.toContain(
+        'interaction-churn',
+      )
+      expect(statusAfterFollowTag.subjectStatuses[0].tags).toContain(
+        'follow-churn',
+      )
+    })
+  })
+})

package/tests/moderation-statuses.test.ts

@@ -39,8 +39,8 @@ describe('moderation-statuses', () => {
     }
     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,
+      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',
@@ -95,6 +95,23 @@ describe('moderation-statuses', () => {
       expect(forSnapshot(response.data.subjectStatuses)).toMatchSnapshot()
     })
 
+    it('returns statuses filtered by subject language', async () => {
+      const klingonQueue = await queryModerationStatuses({
+        tags: ['lang:i'],
+      })
+
+      expect(forSnapshot(klingonQueue.data.subjectStatuses)).toMatchSnapshot()
+
+      const nonKlingonQueue = await queryModerationStatuses({
+        excludeTags: ['lang:i'],
+      })
+
+      // Verify that the klingon tagged subject is not returned when excluding klingon
+      expect(
+        nonKlingonQueue.data.subjectStatuses.map((s) => s.id),
+      ).not.toContain(klingonQueue.data.subjectStatuses[0].id)
+    })
+
     it('returns paginated statuses', async () => {
       // We know there will be exactly 4 statuses in db
       const getPaginatedStatuses = async (
@@ -119,7 +136,7 @@ describe('moderation-statuses', () => {
       }
 
       const list = await getPaginatedStatuses({})
-      expect(list[0].id).toEqual(4)
+      expect(list[0].id).toEqual(7)
       expect(list[list.length - 1].id).toEqual(1)
 
       await emitModerationEvent({