@atproto/ozone 0.2.9 → 0.2.11

package/tests/record-and-account-events.test.ts

@@ -1,197 +0,0 @@
-import assert from 'node:assert'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { isRepoRef } from '../src/lexicon/types/com/atproto/admin/defs.js'
-import { REASONMISLEADING } from '../src/lexicon/types/com/atproto/moderation/defs.js'
-import { isMain as isStrongRef } from '../src/lexicon/types/com/atproto/repo/strongRef.js'
-import {
-  REVIEWOPEN,
-  SubjectStatusView,
-  isAccountHosting,
-  isRecordHosting,
-} from '../src/lexicon/types/tools/ozone/moderation/defs.js'
-import { InputSchema } from '../src/lexicon/types/tools/ozone/moderation/emitEvent.js'
-
-describe('record and account events on moderation subjects', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_record_and_account_events',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const getSubjectStatus = async (
-    subject: string,
-  ): Promise<SubjectStatusView | undefined> => {
-    const res = await modClient.queryStatuses({
-      subject,
-    })
-    return res.subjectStatuses[0]
-  }
-
-  describe('record events', () => {
-    const emitRecordEvent = async (
-      subject: InputSchema['subject'],
-      op: 'create' | 'update' | 'delete',
-    ) => {
-      return await modClient.emitEvent(
-        {
-          event: {
-            op,
-            timestamp: new Date().toISOString(),
-            $type: 'tools.ozone.moderation.defs#recordEvent',
-          },
-          subject,
-          createdBy: 'did:example:admin',
-        },
-        'admin',
-      )
-    }
-
-    it('saves updated and deleted timestamps and record status', async () => {
-      const bobsPostSubject = {
-        $type: 'com.atproto.repo.strongRef',
-        uri: sc.posts[sc.dids.bob][1].ref.uriStr,
-        cid: sc.posts[sc.dids.bob][1].ref.cidStr,
-      }
-
-      await sc.createReport({
-        reportedBy: sc.dids.carol,
-        reasonType: REASONMISLEADING,
-        reason: 'misleading',
-        subject: bobsPostSubject,
-      })
-
-      await emitRecordEvent(bobsPostSubject, 'update')
-      const statusAfterUpdate = await getSubjectStatus(bobsPostSubject.uri)
-      assert(isRecordHosting(statusAfterUpdate?.hosting))
-      expect(statusAfterUpdate.hosting?.updatedAt).toBeTruthy()
-
-      await emitRecordEvent(bobsPostSubject, 'delete')
-      const statusAfterDelete = await getSubjectStatus(bobsPostSubject.uri)
-      assert(isRecordHosting(statusAfterDelete?.hosting))
-      expect(statusAfterDelete.hosting?.deletedAt).toBeTruthy()
-      expect(statusAfterDelete.hosting?.status).toEqual('deleted')
-      // Ensure that due to delete or update event, review state does not change
-      expect(statusAfterDelete.reviewState).toEqual(REVIEWOPEN)
-    })
-  })
-  describe('account/identity events', () => {
-    const emitAccountEvent = async (
-      subject: InputSchema['subject'],
-      active: boolean,
-      status?: 'takendown' | 'deleted' | 'deactivated' | 'suspended',
-    ) => {
-      return await modClient.emitEvent(
-        {
-          event: {
-            status,
-            active,
-            timestamp: new Date().toISOString(),
-            $type: 'tools.ozone.moderation.defs#accountEvent',
-          },
-          subject,
-          createdBy: 'did:example:admin',
-        },
-        'admin',
-      )
-    }
-
-    it('saves updated and deleted timestamps and account status', async () => {
-      const carolsAccountSubject = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.carol,
-      }
-
-      await sc.createReport({
-        reportedBy: sc.dids.carol,
-        reasonType: REASONMISLEADING,
-        reason: 'misleading',
-        subject: carolsAccountSubject,
-      })
-
-      await emitAccountEvent(carolsAccountSubject, false, 'deactivated')
-      const statusAfterDeactivation = await getSubjectStatus(
-        carolsAccountSubject.did,
-      )
-      assert(isAccountHosting(statusAfterDeactivation?.hosting))
-      expect(statusAfterDeactivation.hosting.deactivatedAt).toBeTruthy()
-      expect(statusAfterDeactivation.hosting.status).toEqual('deactivated')
-      expect(statusAfterDeactivation.reviewState).toEqual(REVIEWOPEN)
-
-      await emitAccountEvent(carolsAccountSubject, true)
-      const statusAfterReactivation = await getSubjectStatus(
-        carolsAccountSubject.did,
-      )
-      assert(isAccountHosting(statusAfterReactivation?.hosting))
-      expect(statusAfterReactivation.hosting.updatedAt).toBeTruthy()
-      expect(statusAfterReactivation.hosting.status).toEqual('active')
-      expect(statusAfterReactivation.hosting.deletedAt).toBeFalsy()
-    })
-
-    it('gets statuses by hosting properties', async () => {
-      await Promise.all([
-        emitAccountEvent(
-          {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-          false,
-          'deactivated',
-        ),
-        emitAccountEvent(
-          {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.bob,
-          },
-          false,
-          'deleted',
-        ),
-      ])
-      const [
-        { subjectStatuses: deactivatedOrDeletedStatuses },
-        { subjectStatuses: deletedStatusesInPastDay },
-        { subjectStatuses: deletedStatusesBeforeYesterday },
-      ] = await Promise.all([
-        modClient.queryStatuses({
-          hostingStatuses: ['deactivated', 'deleted'],
-        }),
-        modClient.queryStatuses({
-          hostingDeletedAfter: new Date(
-            Date.now() - 1000 * 60 * 60 * 24,
-          ).toISOString(),
-        }),
-        modClient.queryStatuses({
-          hostingDeletedBefore: new Date(
-            Date.now() - 1000 * 60 * 60 * 24,
-          ).toISOString(),
-        }),
-      ])
-
-      expect(deactivatedOrDeletedStatuses.length).toEqual(3)
-      expect(deletedStatusesInPastDay.length).toEqual(2)
-      assert(isStrongRef(deletedStatusesInPastDay[0]?.subject))
-      expect(deletedStatusesInPastDay[0]?.subject.uri).toEqual(
-        sc.posts[sc.dids.bob][1].ref.uriStr,
-      )
-      assert(isRepoRef(deletedStatusesInPastDay[1]?.subject))
-      expect(deletedStatusesInPastDay[1]?.subject.did).toEqual(sc.dids.bob)
-      expect(deletedStatusesBeforeYesterday.length).toEqual(0)
-    })
-  })
-})

package/tests/repo-search.test.ts

@@ -1,136 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  usersBulkSeed,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import { OutputSchema as SearchReposOutputSchema } from '../src/lexicon/types/tools/ozone/moderation/searchRepos.js'
-import { paginateAll } from './_util.js'
-
-describe('admin repo search view', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let modClient: ModeratorClient
-  let headers: { [s: string]: string }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_admin_repo_search',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await usersBulkSeed(sc)
-    headers = await network.ozone.modHeaders(
-      ids.ToolsOzoneModerationSearchRepos,
-    )
-    await network.processAll()
-  }, 40_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  beforeAll(async () => {
-    await modClient.emitEvent({
-      event: { $type: 'tools.ozone.moderation.defs#modEventTakedown' },
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids['cara-wiegand69.test'],
-      },
-    })
-    await network.ozone.processAll()
-  })
-
-  it('gives relevant results', async () => {
-    const result = await agent.api.tools.ozone.moderation.searchRepos(
-      { term: 'car' },
-      { headers },
-    )
-
-    const handles = result.data.repos.map((u) => u.handle)
-
-    const shouldContain = [
-      'cara-wiegand69.test', // Present despite repo takedown
-      'carlos6.test',
-      'carolina-mcderm77.test',
-    ]
-
-    shouldContain.forEach((handle) => expect(handles).toContain(handle))
-
-    const shouldNotContain = [
-      'sven70.test',
-      'hilario84.test',
-      'santa-hermann78.test',
-      'dylan61.test',
-      'preston-harris.test',
-      'loyce95.test',
-      'melyna-zboncak.test',
-    ]
-
-    shouldNotContain.forEach((handle) => expect(handles).not.toContain(handle))
-  })
-
-  it('finds repo by did', async () => {
-    const term = sc.dids['cara-wiegand69.test']
-    const res = await agent.api.tools.ozone.moderation.searchRepos(
-      { term },
-      { headers },
-    )
-
-    expect(res.data.repos.length).toEqual(1)
-    expect(res.data.repos[0].did).toEqual(term)
-  })
-
-  it('paginates with term', async () => {
-    const results = (results: SearchReposOutputSchema[]) =>
-      results.flatMap((res) => res.repos)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.tools.ozone.moderation.searchRepos(
-        { term: 'p', cursor, limit: 3 },
-        { headers },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator)
-    paginatedAll.forEach((res) =>
-      expect(res.repos.length).toBeLessThanOrEqual(3),
-    )
-
-    const full = await agent.api.tools.ozone.moderation.searchRepos(
-      { term: 'p' },
-      { headers },
-    )
-
-    expect(full.data.repos.length).toBeGreaterThan(3)
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-
-  it('paginates without term', async () => {
-    const results = (results: SearchReposOutputSchema[]) =>
-      results.flatMap((res) => res.repos)
-    const paginator = async (cursor?: string) => {
-      const res = await agent.api.tools.ozone.moderation.searchRepos(
-        { cursor, limit: 3 },
-        { headers },
-      )
-      return res.data
-    }
-
-    const paginatedAll = await paginateAll(paginator, 5)
-    paginatedAll.forEach((res) =>
-      expect(res.repos.length).toBeLessThanOrEqual(3),
-    )
-
-    const full = await agent.api.tools.ozone.moderation.searchRepos(
-      { limit: 15 },
-      { headers },
-    )
-
-    expect(results(paginatedAll)).toEqual(results([full.data]))
-  })
-})

package/tests/report-action.test.ts

@@ -1,308 +0,0 @@
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import {
-  REASONMISLEADING,
-  REASONSPAM,
-} from '../src/lexicon/types/com/atproto/moderation/defs.js'
-
-describe('report-action', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_report_action',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  beforeEach(async () => {
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  describe('emitEvent with reportAction', () => {
-    it('actions specific report IDs and updates status to closed', async () => {
-      // Create 3 reports on bob's account
-      const bobsAccount = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.bob,
-      }
-
-      for (let i = 0; i < 3; i++) {
-        await sc.createReport({
-          reasonType: REASONSPAM,
-          reason: `Spam report ${i}`,
-          subject: bobsAccount,
-          reportedBy: sc.dids.alice,
-        })
-      }
-
-      await network.processAll()
-
-      // Query to get the actual report table IDs
-      const allBobReports = await modClient.queryReports({
-        status: 'open',
-        subject: sc.dids.bob,
-      })
-      const reportIds = allBobReports.reports.map((r) => r.id)
-
-      // Action the first 2 reports with an acknowledge event
-      await modClient.emitEvent({
-        event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
-        subject: bobsAccount,
-        reportAction: {
-          ids: [reportIds[0], reportIds[1]],
-          note: 'Reviewed and found no violation',
-        },
-      })
-
-      // Query reports and verify status — split by expected status since
-      // queryReports requires a status filter
-      const closedBobReports = await modClient.queryReports({
-        status: 'closed',
-        subject: sc.dids.bob,
-      })
-      const openBobReports = await modClient.queryReports({
-        status: 'open',
-        subject: sc.dids.bob,
-      })
-
-      // First 2 should be closed, third should still be open
-      const report1 = closedBobReports.reports.find(
-        (r) => r.id === reportIds[0],
-      )
-      const report2 = closedBobReports.reports.find(
-        (r) => r.id === reportIds[1],
-      )
-      const report3 = openBobReports.reports.find((r) => r.id === reportIds[2])
-
-      expect(report1?.status).toBe('closed')
-      expect(report1?.actionNote).toBe('Reviewed and found no violation')
-      expect(report1?.actionEventIds?.length).toBe(1)
-
-      expect(report2?.status).toBe('closed')
-      expect(report2?.actionNote).toBe('Reviewed and found no violation')
-      expect(report2?.actionEventIds?.length).toBe(1)
-
-      expect(report3?.status).toBe('open')
-      expect(report3?.actionNote).toBeFalsy()
-      expect(report3?.actionEventIds).toBeFalsy()
-    })
-
-    it('actions reports by type and associates multiple events', async () => {
-      // Create mixed reports on alice's account
-      const alicesAccount = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.alice,
-      }
-
-      // Create 2 spam and 2 misleading reports
-      for (let i = 0; i < 2; i++) {
-        await sc.createReport({
-          reasonType: REASONSPAM,
-          reason: `Spam ${i}`,
-          subject: alicesAccount,
-          reportedBy: sc.dids.bob,
-        })
-        await sc.createReport({
-          reasonType: REASONMISLEADING,
-          reason: `Misleading ${i}`,
-          subject: alicesAccount,
-          reportedBy: sc.dids.bob,
-        })
-      }
-
-      await network.processAll()
-
-      // Action only spam reports with takedown
-      const takedownEvent = await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventTakedown',
-          comment: 'Spam account',
-        },
-        subject: alicesAccount,
-        reportAction: {
-          types: ['com.atproto.moderation.defs#reasonSpam'],
-          note: 'Account taken down for spam',
-        },
-      })
-
-      // Later, escalate the misleading reports
-      const escalateEvent = await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventEscalate',
-          comment: 'Needs review',
-        },
-        subject: alicesAccount,
-        reportAction: {
-          types: ['com.atproto.moderation.defs#reasonMisleading'],
-        },
-      })
-
-      // Query and verify
-      const spamReports = await modClient.queryReports({
-        status: 'closed',
-        subject: sc.dids.alice,
-        reportTypes: [REASONSPAM],
-      })
-      const misleadingReports = await modClient.queryReports({
-        status: 'escalated',
-        subject: sc.dids.alice,
-        reportTypes: [REASONMISLEADING],
-      })
-
-      // Spam reports should be closed with takedown event ID
-      expect(spamReports.reports.length).toBe(2)
-      spamReports.reports.forEach((report) => {
-        expect(report.status).toBe('closed')
-        expect(report.actionNote).toBe('Account taken down for spam')
-        expect(report.actionEventIds).toContain(takedownEvent.id)
-      })
-
-      // Misleading reports should be escalated with escalate event ID
-      expect(misleadingReports.reports.length).toBe(2)
-      misleadingReports.reports.forEach((report) => {
-        expect(report.status).toBe('escalated')
-        expect(report.actionEventIds).toContain(escalateEvent.id)
-      })
-    })
-
-    it('actions all reports on a subject and dismisses with comment event', async () => {
-      // Create a post with multiple reports (use Carol's post to avoid conflicts)
-      const carolsPost = {
-        $type: 'com.atproto.repo.strongRef',
-        uri: sc.posts[sc.dids.carol][0].ref.uriStr,
-        cid: sc.posts[sc.dids.carol][0].ref.cidStr,
-      }
-
-      // Create 3 reports of different types
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'Spam post',
-        subject: carolsPost,
-        reportedBy: sc.dids.bob,
-      })
-      await sc.createReport({
-        reasonType: REASONMISLEADING,
-        reason: 'Misleading content',
-        subject: carolsPost,
-        reportedBy: sc.dids.bob,
-      })
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'Another spam report',
-        subject: carolsPost,
-        reportedBy: sc.dids.dan,
-      })
-
-      await network.processAll()
-
-      // Dismiss all reports with a comment (no subject action)
-      await modClient.emitEvent({
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventComment',
-          comment: 'False positive',
-        },
-        subject: carolsPost,
-        reportAction: {
-          all: true,
-          note: 'Thank you for reporting. No violation found.',
-        },
-      })
-
-      // Query reports on this post
-      const postReports = await modClient.queryReports({
-        status: 'closed',
-        subject: carolsPost.uri,
-      })
-
-      // All 3 reports should be closed
-      expect(postReports.reports.length).toBe(3)
-      postReports.reports.forEach((report) => {
-        expect(report.status).toBe('closed')
-        expect(report.actionNote).toBe(
-          'Thank you for reporting. No violation found.',
-        )
-        expect(report.actionEventIds?.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('validates report IDs belong to the subject and throws error for mismatches', async () => {
-      // Create reports on two different subjects (use carol and dan to avoid conflicts)
-      const carolsAccount = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.carol,
-      }
-      const dansAccount = {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.dan,
-      }
-
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'Spam',
-        subject: carolsAccount,
-        reportedBy: sc.dids.bob,
-      })
-
-      await sc.createReport({
-        reasonType: REASONSPAM,
-        reason: 'Spam',
-        subject: dansAccount,
-        reportedBy: sc.dids.bob,
-      })
-
-      await network.processAll()
-
-      // Query to get actual report table IDs
-      const carolReports = await modClient.queryReports({
-        status: 'open',
-        subject: sc.dids.carol,
-      })
-      const danReports = await modClient.queryReports({
-        status: 'open',
-        subject: sc.dids.dan,
-      })
-
-      const carolReportId = carolReports.reports[0].id
-      const danReportId = danReports.reports[0].id
-
-      // Try to action dan's report while targeting carol's account - should fail
-      const promise = modClient.emitEvent({
-        event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
-        subject: carolsAccount,
-        reportAction: {
-          ids: [danReportId],
-          note: 'This should fail',
-        },
-      })
-
-      await expect(promise).rejects.toThrow(
-        /No matching reports found|do not exist or do not belong/,
-      )
-
-      // Verify carol's report was not affected
-      const carolReportsAfter = await modClient.queryReports({
-        status: 'open',
-        subject: sc.dids.carol,
-      })
-      const report = carolReportsAfter.reports.find(
-        (r) => r.id === carolReportId,
-      )
-      expect(report?.status).toBe('open')
-      expect(report?.actionEventIds).toBeFalsy()
-    })
-  })
-})