@atproto/ozone 0.2.8 → 0.2.11

package/tests/moderation-events.test.ts

@@ -1,756 +0,0 @@
-import assert from 'node:assert'
-import EventEmitter, { once } from 'node:events'
-import { ToolsOzoneModerationDefs } from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs.js'
-import {
-  REASONAPPEAL,
-  REASONMISLEADING,
-  REASONSPAM,
-} from '../src/lexicon/types/com/atproto/moderation/defs.js'
-import { isMain as isStrongRef } from '../src/lexicon/types/com/atproto/repo/strongRef.js'
-import { forSnapshot } from './_util.js'
-
-describe('moderation-events', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  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 sc.createReport({
-        reasonType: i % 2 ? REASONSPAM : REASONMISLEADING,
-        reason: 'X',
-        //   Report bob's account by alice and vice versa
-        subject: i % 2 ? bobsAccount : alicesAccount,
-        reportedBy: i % 2 ? sc.dids.alice : sc.dids.bob,
-      })
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'X',
-        //   Report bob's post by alice and vice versa
-        subject: i % 2 ? bobsPost : alicesPost,
-        reportedBy: i % 2 ? sc.dids.alice : sc.dids.bob,
-      })
-    }
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_moderation_events',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-    await seedEvents()
-  })
-
-  beforeEach(async () => {
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  describe('query events', () => {
-    it('returns all events for record or repo', async () => {
-      const [bobsEvents, alicesPostEvents] = await Promise.all([
-        modClient.queryEvents({
-          subject: sc.dids.bob,
-        }),
-        modClient.queryEvents({
-          subject: sc.posts[sc.dids.alice][0].ref.uriStr,
-        }),
-      ])
-
-      expect(forSnapshot(bobsEvents.events)).toMatchSnapshot()
-      expect(forSnapshot(alicesPostEvents.events)).toMatchSnapshot()
-    })
-
-    it('filters events by types', async () => {
-      const alicesAccount = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      }
-      await Promise.all([
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventComment',
-            comment: 'X',
-          },
-          subject: alicesAccount,
-        }),
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventEscalate',
-            comment: 'X',
-          },
-          subject: alicesAccount,
-        }),
-      ])
-      const [allEvents, reportEvents] = await Promise.all([
-        modClient.queryEvents({
-          subject: sc.dids.alice,
-        }),
-        modClient.queryEvents({
-          subject: sc.dids.alice,
-          types: ['tools.ozone.moderation.defs#modEventReport'],
-        }),
-      ])
-
-      expect(allEvents.events.length).toBeGreaterThan(
-        reportEvents.events.length,
-      )
-      expect(
-        [...new Set(reportEvents.events.map((e) => e.event.$type))].length,
-      ).toEqual(1)
-
-      expect(
-        [...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([
-        modClient.queryEvents({
-          subject: sc.dids.bob,
-          includeAllUserRecords: true,
-        }),
-        modClient.queryEvents({
-          subject: sc.posts[sc.dids.bob][0].ref.uriStr,
-          includeAllUserRecords: true,
-        }),
-      ])
-
-      expect(forAccount.events.length).toEqual(forPost.events.length)
-      // Save events are returned from both requests
-      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 modClient.queryEvents({
-        subject: sc.dids.bob,
-        includeAllUserRecords: true,
-      })
-
-      const getPaginatedEvents = async (
-        sortDirection: 'asc' | 'desc' = 'desc',
-      ) => {
-        let defaultCursor: undefined | string = undefined
-        const events: ToolsOzoneModerationDefs.ModEventView[] = []
-        let count = 0
-        do {
-          // get 1 event at a time and check we get all events
-          const res = await modClient.queryEvents({
-            limit: 1,
-            subject: sc.dids.bob,
-            includeAllUserRecords: true,
-            cursor: defaultCursor,
-            sortDirection,
-          })
-          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)
-
-        return events
-      }
-
-      const defaultEvents = await getPaginatedEvents()
-      const reversedEvents = await getPaginatedEvents('asc')
-
-      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[defaultEvents.length - 1].id,
-      )
-    })
-
-    it('returns report events matching reportType filters', async () => {
-      const [spamEvents, misleadingEvents] = await Promise.all([
-        modClient.queryEvents({
-          reportTypes: [REASONSPAM],
-        }),
-        modClient.queryEvents({
-          reportTypes: [REASONMISLEADING, REASONAPPEAL],
-        }),
-      ])
-
-      // Verify all spam events have the correct report type
-      expect(spamEvents.events.length).toEqual(6)
-      spamEvents.events.forEach((event) => {
-        expect(event.event.$type).toEqual(
-          'tools.ozone.moderation.defs#modEventReport',
-        )
-        expect((event.event as any).reportType).toEqual(REASONSPAM)
-      })
-
-      // Verify all misleading events have one of the correct report types
-      expect(misleadingEvents.events.length).toEqual(2)
-      misleadingEvents.events.forEach((event) => {
-        expect(event.event.$type).toEqual(
-          'tools.ozone.moderation.defs#modEventReport',
-        )
-        expect([REASONMISLEADING, REASONAPPEAL]).toContain(
-          (event.event as any).reportType,
-        )
-      })
-    })
-
-    it('returns events matching keyword in comment', async () => {
-      const [eventsWithX, eventsWithTest, eventsWithComment] =
-        await Promise.all([
-          modClient.queryEvents({
-            comment: 'X',
-          }),
-          modClient.queryEvents({
-            comment: 'test',
-          }),
-          modClient.queryEvents({
-            hasComment: true,
-          }),
-        ])
-
-      expect(eventsWithX.events.length).toEqual(10)
-      expect(eventsWithTest.events.length).toEqual(0)
-      expect(eventsWithComment.events.length).toEqual(10)
-    })
-
-    it('returns events matching multiple keywords in comment', async () => {
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'november rain',
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        reportedBy: sc.dids.bob,
-      })
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'rainy days feel lazy',
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        reportedBy: sc.dids.bob,
-      })
-      const [eventsMatchingBothKeywords, unusedTrailingSeparator, extraSpaces] =
-        await Promise.all([
-          modClient.queryEvents({
-            hasComment: true,
-            comment: 'november||lazy',
-          }),
-          modClient.queryEvents({
-            hasComment: true,
-            comment: 'november||lazy||',
-          }),
-          modClient.queryEvents({
-            hasComment: true,
-            comment: '||november||lazy||  ',
-          }),
-        ])
-
-      expect(forSnapshot(eventsMatchingBothKeywords.events)).toMatchSnapshot()
-      expect(forSnapshot(unusedTrailingSeparator.events)).toMatchSnapshot()
-      expect(forSnapshot(extraSpaces.events)).toMatchSnapshot()
-    })
-
-    it('returns events matching filter params for labels', async () => {
-      const [negatedLabelEvent, createdLabelEvent] = await Promise.all([
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventLabel',
-            comment: 'X',
-            negateLabelVals: ['L1', 'L2'],
-            createLabelVals: [],
-          },
-          //   Report bob's account by alice and vice versa
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.alice,
-          },
-        }),
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventLabel',
-            comment: 'X',
-            createLabelVals: ['L1', 'L2'],
-            negateLabelVals: [],
-          },
-          //   Report bob's account by alice and vice versa
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.bob,
-          },
-        }),
-      ])
-      const [withTwoLabels, withoutTwoLabels, withOneLabel, withoutOneLabel] =
-        await Promise.all([
-          modClient.queryEvents({
-            addedLabels: ['L1', 'L3'],
-          }),
-          modClient.queryEvents({
-            removedLabels: ['L1', 'L2'],
-          }),
-          modClient.queryEvents({
-            addedLabels: ['L1'],
-          }),
-          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.events.length).toEqual(0)
-      expect(negatedLabelEvent.id).toEqual(withoutTwoLabels.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 ({
-        add,
-        remove,
-      }: {
-        add: string[]
-        remove: string[]
-      }) =>
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventTag',
-            comment: 'X',
-            add,
-            remove,
-          },
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-        })
-      const addEvent = await tagEvent({ add: ['L1', 'L2'], remove: [] })
-      const addAndRemoveEvent = await tagEvent({ add: ['L3'], remove: ['L2'] })
-      const [addFinder, addAndRemoveFinder, _removeFinder] = await Promise.all([
-        modClient.queryEvents({
-          addedTags: ['L1'],
-        }),
-        modClient.queryEvents({
-          addedTags: ['L3'],
-          removedTags: ['L2'],
-        }),
-        modClient.queryEvents({
-          removedTags: ['L2'],
-        }),
-      ])
-
-      expect(addFinder.events.length).toEqual(1)
-      expect(addEvent.id).toEqual(addFinder.events[0].id)
-
-      expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
-      expect(addAndRemoveEvent.id).toEqual(addAndRemoveFinder.events[0].id)
-      assert(ToolsOzoneModerationDefs.isModEventTag(addAndRemoveEvent.event))
-      expect(addAndRemoveEvent.event.add).toEqual(['L3'])
-      expect(addAndRemoveEvent.event.remove).toEqual(['L2'])
-    })
-
-    it('returns events for specified collections', async () => {
-      const sp = await sc.createStarterPack(
-        sc.dids.alice,
-        "alice's about to get blocked starter pack",
-        [sc.dids.bob, sc.dids.carol],
-        [],
-      )
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'X',
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          ...sp.raw,
-        },
-        reportedBy: sc.dids.bob,
-      })
-
-      const [
-        onlyStarterPackReports,
-        onlyAlicesStarterPackReports,
-        onlyBobsStarterPackReports,
-        onlyPostReports,
-      ] = await Promise.all([
-        modClient.queryEvents({
-          types: ['tools.ozone.moderation.defs#modEventReport'],
-          collections: ['app.bsky.graph.starterpack'],
-        }),
-        modClient.queryEvents({
-          subject: sc.dids.alice,
-          includeAllUserRecords: true,
-          types: ['tools.ozone.moderation.defs#modEventReport'],
-          collections: ['app.bsky.graph.starterpack'],
-        }),
-        modClient.queryEvents({
-          subject: sc.dids.bob,
-          includeAllUserRecords: true,
-          types: ['tools.ozone.moderation.defs#modEventReport'],
-          collections: ['app.bsky.graph.starterpack'],
-        }),
-        modClient.queryEvents({
-          types: ['tools.ozone.moderation.defs#modEventReport'],
-          collections: ['app.bsky.feed.post'],
-        }),
-      ])
-
-      expect(onlyStarterPackReports.events.length).toEqual(1)
-      assert(isStrongRef(onlyStarterPackReports.events[0].subject))
-      expect(onlyStarterPackReports.events[0].subject.uri).toContain(
-        'app.bsky.graph.starterpack',
-      )
-
-      expect(onlyAlicesStarterPackReports.events.length).toEqual(1)
-      assert(isStrongRef(onlyAlicesStarterPackReports.events[0].subject))
-      expect(onlyAlicesStarterPackReports.events[0].subject.uri).toContain(
-        sp.uriStr,
-      )
-      expect(onlyBobsStarterPackReports.events.length).toEqual(0)
-      expect(onlyPostReports.events.length).toEqual(4)
-    })
-
-    it('returns events for account or records', async () => {
-      const [onlyAccountReports, onlyRecordReports, onlyReportsOnBobsAccount] =
-        await Promise.all([
-          modClient.queryEvents({
-            types: ['tools.ozone.moderation.defs#modEventReport'],
-            subjectType: 'account',
-          }),
-          modClient.queryEvents({
-            types: ['tools.ozone.moderation.defs#modEventReport'],
-            subjectType: 'record',
-          }),
-          modClient.queryEvents({
-            subject: sc.dids.bob,
-            types: ['tools.ozone.moderation.defs#modEventReport'],
-            subjectType: 'record',
-          }),
-        ])
-
-      assert(
-        onlyAccountReports.events.every((e) => !isStrongRef(e.subject)),
-        'only account reports are returned, no event has a uri',
-      )
-
-      assert(
-        onlyRecordReports.events.every(
-          (e) => isStrongRef(e.subject) && e.subject.uri,
-        ),
-        'only record reports are returned, all events have a uri',
-      )
-
-      assert(
-        onlyReportsOnBobsAccount.events.every(
-          (e) => isRepoRef(e.subject) && e.subject.did === sc.dids.bob,
-        ),
-        "only bob's account reports are returned, no events have a URI even though the subjectType is record",
-      )
-    })
-
-    it('queries events by creator', async () => {
-      const now = new Date()
-      const startDate = new Date(now.getTime() - 24 * 60 * 60 * 1000) // 1 day ago
-      const endDate = new Date(now.getTime() + 24 * 60 * 60 * 1000) // 1 day from now
-
-      const events = await modClient.queryEvents({
-        createdBy: network.ozone.moderatorAccnt.did,
-        createdAfter: startDate.toISOString(),
-        createdBefore: endDate.toISOString(),
-        limit: 25,
-        sortDirection: 'desc',
-      })
-
-      expect(events.events.length).toBeGreaterThan(0)
-      expect(events.events.length).toBeLessThanOrEqual(25)
-
-      // Verify sorting
-      for (let i = 1; i < events.events.length; i++) {
-        const prev = events.events[i - 1]
-        const curr = events.events[i]
-        const prevTime = new Date(prev.createdAt).getTime()
-        const currTime = new Date(curr.createdAt).getTime()
-
-        if (prevTime === currTime) {
-          expect(prev.id).toBeGreaterThan(curr.id)
-        } else {
-          expect(prevTime).toBeGreaterThan(currTime)
-        }
-      }
-
-      // Verify createdBy is correct
-      events.events.forEach((event) => {
-        expect(event.createdBy).toEqual(network.ozone.moderatorAccnt.did)
-      })
-    })
-
-    it('queries events by conversation', async () => {
-      const convoId1 = 'conversation-123'
-      const convoId2 = 'conversation-456'
-
-      // create reports
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'spam in convo 1',
-        subject: {
-          $type: 'chat.bsky.convo.defs#convoRef',
-          did: sc.dids.carol,
-          convoId: convoId1,
-        },
-        reportedBy: sc.dids.alice,
-      })
-      await sc.createReport({
-        reasonType: REASONMISLEADING,
-        reason: 'misleading in convo 1',
-        subject: {
-          $type: 'chat.bsky.convo.defs#convoRef',
-          did: sc.dids.carol,
-          convoId: convoId1,
-        },
-        reportedBy: sc.dids.bob,
-      })
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'spam in convo 2',
-        subject: {
-          $type: 'chat.bsky.convo.defs#convoRef',
-          did: sc.dids.carol,
-          convoId: convoId2,
-        },
-        reportedBy: sc.dids.alice,
-      })
-
-      // Query events (filter by report type since auto-tagging creates extra events)
-      const convo1Events = await modClient.queryEvents({
-        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId1}`,
-        includeAllUserRecords: false,
-        types: ['tools.ozone.moderation.defs#modEventReport'],
-      })
-      const convo2Events = await modClient.queryEvents({
-        subject: `at://${sc.dids.carol}/chat.bsky.convo/${convoId2}`,
-        includeAllUserRecords: false,
-        types: ['tools.ozone.moderation.defs#modEventReport'],
-      })
-
-      // Verify conversation 1 events are correct
-      expect(convo1Events.events.length).toBeGreaterThan(0)
-      convo1Events.events.forEach((e) => {
-        // All events should be conversation refs
-        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
-        // All events should be for conversation 1
-        const subject = e.subject as any
-        expect(subject.convoId).toEqual(convoId1)
-        expect(subject.did).toEqual(sc.dids.carol)
-        // All events should be reports
-        expect(e.event.$type).toEqual(
-          'tools.ozone.moderation.defs#modEventReport',
-        )
-      })
-      // Verify we got both reports we created
-      const convo1Comments = convo1Events.events.map(
-        (e) => (e.event as any).comment,
-      )
-      expect(convo1Comments).toContain('spam in convo 1')
-      expect(convo1Comments).toContain('misleading in convo 1')
-
-      // Verify conversation 2 events are correct
-      expect(convo2Events.events.length).toBeGreaterThan(0)
-      convo2Events.events.forEach((e) => {
-        // All events should be conversation refs
-        expect(e.subject.$type).toEqual('chat.bsky.convo.defs#convoRef')
-        // All events should be for conversation 2
-        const subject = e.subject as any
-        expect(subject.convoId).toEqual(convoId2)
-        expect(subject.did).toEqual(sc.dids.carol)
-        // All events should be reports
-        expect(e.event.$type).toEqual(
-          'tools.ozone.moderation.defs#modEventReport',
-        )
-      })
-      // Verify we got the report we created
-      const convo2Comments = convo2Events.events.map(
-        (e) => (e.event as any).comment,
-      )
-      expect(convo2Comments).toContain('spam in convo 2')
-    })
-  })
-
-  describe('get event', () => {
-    it('gets an event by specific id', async () => {
-      const data = await modClient.getEvent(1)
-      expect(forSnapshot(data)).toMatchSnapshot()
-    })
-  })
-
-  describe('deduping by external id', () => {
-    it('fails on events with duplicate external id', async () => {
-      const externalId = 'external-id-1'
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#ageAssuranceEvent',
-          status: 'pending',
-          createdAt: new Date().toISOString(),
-          attemptId: 'attempt-1',
-        },
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        externalId,
-      })
-      await expect(
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#ageAssuranceEvent',
-            status: 'pending',
-            createdAt: new Date().toISOString(),
-            attemptId: 'attempt-1',
-          },
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.alice,
-          },
-          externalId,
-        }),
-      ).rejects.toThrow(
-        'An event with the same external ID already exists for the subject.',
-      )
-    })
-  })
-
-  describe('blobs', () => {
-    it('are tracked on takedown event', async () => {
-      const post = sc.posts[sc.dids.carol][0]
-      assert(post.images.length > 1)
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        },
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: post.ref.uriStr,
-          cid: post.ref.cidStr,
-        },
-        subjectBlobCids: [post.images[0].image.ref.toString()],
-      })
-      const result = await modClient.queryEvents({
-        subject: post.ref.uriStr,
-        types: ['tools.ozone.moderation.defs#modEventTakedown'],
-      })
-      expect(result.events[0]).toMatchObject({
-        createdBy: network.ozone.moderatorAccnt.did,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        },
-        subjectBlobCids: [post.images[0].image.ref.toString()],
-      })
-    })
-
-    it("are tracked on reverse-takedown event even if they aren't specified", async () => {
-      const post = sc.posts[sc.dids.carol][0]
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
-        },
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: post.ref.uriStr,
-          cid: post.ref.cidStr,
-        },
-      })
-      const result = await modClient.queryEvents({
-        subject: post.ref.uriStr,
-      })
-      expect(result.events[0]).toMatchObject({
-        createdBy: network.ozone.moderatorAccnt.did,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventReverseTakedown',
-        },
-        subjectBlobCids: [post.images[0].image.ref.toString()],
-      })
-    })
-  })
-
-  describe('email event', () => {
-    let sendMailOriginal
-    const mailCatcher = new EventEmitter()
-    const getMailFrom = async (
-      promise,
-    ): Promise<{ to: string; subject: string; from: string }> => {
-      const result = await Promise.all([once(mailCatcher, 'mail'), promise])
-      return result[0][0]
-    }
-
-    beforeAll(() => {
-      const mailer = network.pds.ctx.moderationMailer
-      // Catch emails for use in tests
-      sendMailOriginal = mailer.transporter.sendMail
-      mailer.transporter.sendMail = async (opts) => {
-        const result = await sendMailOriginal.call(mailer.transporter, opts)
-        mailCatcher.emit('mail', opts)
-        return result
-      }
-    })
-
-    afterAll(() => {
-      network.pds.ctx.moderationMailer.transporter.sendMail = sendMailOriginal
-    })
-
-    it('sends email via pds.', async () => {
-      const mail = await getMailFrom(
-        modClient.emitEvent({
-          event: {
-            $type: 'tools.ozone.moderation.defs#modEventEmail',
-            comment: 'Reaching out to Alice',
-            subjectLine: 'Hello',
-            content: 'Hey Alice, how are you?',
-          },
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.alice,
-          },
-        }),
-      )
-      expect(mail).toEqual({
-        to: 'alice@test.com',
-        subject: 'Hello',
-        html: 'Hey Alice, how are you?',
-      })
-    })
-  })
-})