@atproto/ozone 0.2.9 → 0.2.11

package/tests/strike-expiry-processor.test.ts

@@ -1,299 +0,0 @@
-import AtpAgent from '@atproto/api'
-import { SECOND } from '@atproto/common'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import { SeverityLevelSettingKey } from '../src/setting/constants.js'
-
-const strikeConfig = {
-  'sev-1': {
-    strikeCount: 1,
-    expiresInDays: 0, // Set to 0 so we can use future timestamps
-  },
-  'sev-2': {
-    strikeCount: 2,
-    expiresInDays: 0,
-  },
-}
-
-describe('strike expiry processor', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  const repoSubject = (did: string) => ({
-    $type: 'com.atproto.admin.defs#repoRef',
-    did,
-  })
-
-  const configureSeverityLevels = async () => {
-    await agent.tools.ozone.setting.upsertOption(
-      {
-        scope: 'instance',
-        key: SeverityLevelSettingKey,
-        value: strikeConfig,
-        description: 'Severity level configuration for strike system',
-        managerRole: 'tools.ozone.team.defs#roleAdmin',
-      },
-      {
-        encoding: 'application/json',
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneSettingUpsertOption,
-          'admin',
-        ),
-      },
-    )
-  }
-
-  const getAccountStatus = async (did: string) => {
-    const { subjectStatuses } = await modClient.queryStatuses({ subject: did })
-    return subjectStatuses[0]
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_strike_expiry_processor',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-    await configureSeverityLevels()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('processes expired strikes and updates active strike count', async () => {
-    const bobDid = sc.dids.bob
-    const bobPost1 = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[bobDid][0].ref.uriStr,
-      cid: sc.posts[bobDid][0].ref.cidStr,
-    }
-    const bobPost2 = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: sc.posts[bobDid][1].ref.uriStr,
-      cid: sc.posts[bobDid][1].ref.cidStr,
-    }
-
-    // first strike on a post that expires in 2 seconds
-    const expiresAt1 = new Date(Date.now() + 2 * SECOND).toISOString()
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-2',
-        strikeCount: 2,
-        strikeExpiresAt: expiresAt1,
-        comment: 'First violation - expires soon',
-      },
-      subject: bobPost1,
-    })
-
-    // second strike on another post that expires in 3 seconds
-    const expiresAt2 = new Date(Date.now() + 3 * SECOND).toISOString()
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        strikeCount: 1,
-        severityLevel: 'sev-1',
-        strikeExpiresAt: expiresAt2,
-        comment: 'Second violation - expires later',
-      },
-      subject: bobPost2,
-    })
-
-    // account-level event to ensure account status is created
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventComment',
-        comment: 'Account under review',
-      },
-      subject: repoSubject(bobDid),
-    })
-
-    // Verify initial state - both strikes are active
-    let status = await getAccountStatus(bobDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(3) // 2 + 1
-    expect(status.accountStrike!.totalStrikeCount).toBe(3)
-
-    // Wait for first strike to expire
-    await new Promise((resolve) => setTimeout(resolve, 2.1 * SECOND))
-
-    // Run the processor
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Verify first strike expired - only second strike remains active
-    status = await getAccountStatus(bobDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(1) // Only second strike
-    expect(status.accountStrike!.totalStrikeCount).toBe(3) // Total unchanged
-
-    // Wait for second strike to expire
-    await new Promise((resolve) => setTimeout(resolve, 1 * SECOND))
-
-    // Run the processor again
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Verify all strikes expired
-    status = await getAccountStatus(bobDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(0)
-    expect(status.accountStrike!.totalStrikeCount).toBe(3) // Total unchanged
-  })
-
-  it('handles accounts with no expired strikes', async () => {
-    const aliceDid = sc.dids.alice
-
-    // strike that expires far in the future
-    const expiresAt = new Date(Date.now() + 1000 * SECOND).toISOString()
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-2',
-        strikeCount: 2,
-        strikeExpiresAt: expiresAt,
-        comment: 'Future expiry',
-      },
-      subject: repoSubject(aliceDid),
-    })
-
-    // Get initial state
-    let status = await getAccountStatus(aliceDid)
-    expect(status.accountStrike).toBeDefined()
-    const initialActiveCount = status.accountStrike!.activeStrikeCount!
-    expect(initialActiveCount).toBe(2)
-
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Verify nothing changed
-    status = await getAccountStatus(aliceDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(initialActiveCount)
-  })
-
-  it('handles strikes with no expiry date (permanent strikes)', async () => {
-    const carolDid = sc.dids.carol
-
-    // permanent strike (no expiry)
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-2',
-        strikeCount: 2,
-        comment: 'Permanent strike - no expiry',
-      },
-      subject: repoSubject(carolDid),
-    })
-
-    // Get initial state
-    let status = await getAccountStatus(carolDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(2)
-
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Verify permanent strikes remain active
-    status = await getAccountStatus(carolDid)
-    expect(status.accountStrike).toBeDefined()
-    expect(status.accountStrike!.activeStrikeCount).toBe(2)
-    expect(status.accountStrike!.totalStrikeCount).toBe(2)
-  })
-
-  it('processes multiple accounts with expired strikes in batch', async () => {
-    const danDid = 'did:plc:dan'
-    const eveDid = 'did:plc:eve'
-
-    const expiresAt = new Date(Date.now() + 1 * SECOND).toISOString()
-
-    // strikes to multiple accounts
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-1',
-        strikeCount: 1,
-        strikeExpiresAt: expiresAt,
-        comment: 'Dan violation',
-      },
-      subject: repoSubject(danDid),
-    })
-
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-2',
-        strikeCount: 2,
-        strikeExpiresAt: expiresAt,
-        comment: 'Eve violation',
-      },
-      subject: repoSubject(eveDid),
-    })
-
-    // Verify initial states
-    let danStatus = await getAccountStatus(danDid)
-    let eveStatus = await getAccountStatus(eveDid)
-    expect(danStatus.accountStrike?.activeStrikeCount).toBe(1)
-    expect(eveStatus.accountStrike?.activeStrikeCount).toBe(2)
-
-    // Wait for strikes to expire
-    await new Promise((resolve) => setTimeout(resolve, 1.1 * SECOND))
-
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Verify both accounts' strikes expired
-    danStatus = await getAccountStatus(danDid)
-    eveStatus = await getAccountStatus(eveDid)
-    expect(danStatus.accountStrike?.activeStrikeCount).toBe(0)
-    expect(eveStatus.accountStrike?.activeStrikeCount).toBe(0)
-  })
-
-  it('updates cursor to track last processed timestamp', async () => {
-    const frankDid = 'did:plc:frank'
-    const expiresAt = new Date(Date.now() + 1 * SECOND).toISOString()
-
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        severityLevel: 'sev-1',
-        strikeCount: 1,
-        strikeExpiresAt: expiresAt,
-        comment: 'Frank violation',
-      },
-      subject: repoSubject(frankDid),
-    })
-
-    // Wait for strike to expire
-    await new Promise((resolve) => setTimeout(resolve, 1.1 * SECOND))
-
-    // Get cursor before processing
-    const cursorBefore =
-      await network.ozone.daemon.ctx.strikeExpiryProcessor.getCursor()
-
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-
-    // Get cursor after processing
-    const cursorAfter =
-      await network.ozone.daemon.ctx.strikeExpiryProcessor.getCursor()
-
-    expect(cursorAfter).not.toBe(cursorBefore)
-    expect(cursorAfter).toBeTruthy()
-
-    // Verify strike was processed
-    const status = await getAccountStatus(frankDid)
-    expect(status.accountStrike?.activeStrikeCount).toBe(0)
-
-    // running processor again should not reprocess the same strike
-    await network.ozone.daemon.ctx.strikeExpiryProcessor.processExpiredStrikes()
-    const cursorAfterSecond =
-      await network.ozone.daemon.ctx.strikeExpiryProcessor.getCursor()
-    expect(cursorAfterSecond).not.toBe(cursorAfter)
-  })
-})

package/tests/subject-priority-score.test.ts

@@ -1,96 +0,0 @@
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { REASONSPAM } from '../dist/lexicon/types/com/atproto/moderation/defs.js'
-
-describe('moderation', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_priority_score',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await Promise.all([
-      sc.createReport({
-        reasonType: REASONSPAM,
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.bob,
-        },
-        reportedBy: sc.dids.carol,
-      }),
-      sc.createReport({
-        reasonType: REASONSPAM,
-        subject: {
-          $type: 'com.atproto.admin.defs#repoRef',
-          did: sc.dids.alice,
-        },
-        reportedBy: sc.dids.carol,
-      }),
-      sc.createReport({
-        reasonType: REASONSPAM,
-        subject: {
-          $type: 'com.atproto.repo.strongRef',
-          uri: sc.posts[sc.dids.bob][0].ref.uriStr,
-          cid: sc.posts[sc.dids.bob][0].ref.cidStr,
-        },
-        reportedBy: sc.dids.carol,
-      }),
-    ])
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('allows setting a priority score.', async () => {
-    const { subjectStatuses: before } = await modClient.queryStatuses({})
-    await Promise.all([
-      modClient.emitEvent({
-        subject: before[before.length - 1].subject,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventPriorityScore',
-          score: 10,
-        },
-      }),
-      modClient.emitEvent({
-        subject: before[before.length - 2].subject,
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventPriorityScore',
-          score: 5,
-        },
-      }),
-    ])
-    const { subjectStatuses: after } = await modClient.queryStatuses({
-      sortDirection: 'desc',
-      sortField: 'priorityScore',
-    })
-
-    // Verify that highest priority score item is first
-    expect(after[0].priorityScore).toBe(10)
-    expect(after[1].priorityScore).toBe(5)
-    expect(after[0].subject).toMatchObject(before[before.length - 1].subject)
-    expect(after[1].subject).toMatchObject(before[before.length - 2].subject)
-  })
-
-  it('allows setting a priority score.', async () => {
-    const { subjectStatuses } = await modClient.queryStatuses({
-      minPriorityScore: 6,
-      sortDirection: 'desc',
-      sortField: 'priorityScore',
-    })
-
-    // Verify that highest priority score item is first
-    expect(subjectStatuses[0].priorityScore).toBe(10)
-    expect(subjectStatuses.length).toBe(1)
-  })
-})

package/tests/takedown.test.ts

@@ -1,105 +0,0 @@
-import assert from 'node:assert'
-import {
-  AtpAgent,
-  ComAtprotoAdminDefs,
-  ToolsOzoneModerationDefs,
-} from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-
-describe('moderation', () => {
-  let network: TestNetwork
-
-  let sc: SeedClient
-  let modClient: ModeratorClient
-  let pdsAgent: AtpAgent
-  let bskyAgent: AtpAgent
-
-  const repoSubject = (did: string) => ({
-    $type: 'com.atproto.admin.defs#repoRef',
-    did,
-  })
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_takedown',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    pdsAgent = network.pds.getAgent()
-    bskyAgent = network.bsky.getAgent()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('allows specifying policy for takedown actions.', async () => {
-    await modClient.performTakedown({
-      subject: repoSubject(sc.dids.bob),
-      policies: ['trolling'],
-    })
-
-    // Verify that that the takedown even exposes the policy specified for it
-    const { events: eventViews } = await modClient.queryEvents({
-      subject: sc.dids.bob,
-      types: ['tools.ozone.moderation.defs#modEventTakedown'],
-    })
-
-    const { event } = eventViews[0]
-
-    assert(ToolsOzoneModerationDefs.isModEventTakedown(event))
-    expect(event.policies?.[0]).toEqual('trolling')
-
-    // Verify that event stream can be filtered by policy
-    const { events: filteredEvents } = await modClient.queryEvents({
-      subject: sc.dids.bob,
-      policies: ['trolling'],
-    })
-
-    const { subject } = filteredEvents[0]
-
-    assert(ComAtprotoAdminDefs.isRepoRef(subject))
-    expect(subject.did).toEqual(sc.dids.bob)
-  })
-
-  it('applies takedown only to specified service when targetServices is set', async () => {
-    await modClient.emitEvent({
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTakedown',
-        targetServices: ['appview'],
-      },
-      subject: repoSubject(sc.dids.carol),
-    })
-
-    await network.processAll()
-
-    const [pdsStatus, appviewStatus, carolsEvents] = await Promise.all([
-      pdsAgent.com.atproto.admin.getSubjectStatus(
-        { did: sc.dids.carol },
-        { headers: network.pds.adminAuthHeaders() },
-      ),
-      bskyAgent.com.atproto.admin.getSubjectStatus(
-        { did: sc.dids.carol },
-        { headers: network.bsky.adminAuthHeaders() },
-      ),
-      modClient.queryEvents({
-        subject: sc.dids.carol,
-        types: ['tools.ozone.moderation.defs#modEventTakedown'],
-      }),
-    ])
-
-    expect(pdsStatus.data.takedown?.applied).toBe(false)
-    expect(appviewStatus.data.takedown?.applied).toBe(true)
-
-    const event = carolsEvents.events[0].event
-    assert(ToolsOzoneModerationDefs.isModEventTakedown(event))
-    expect(event.targetServices).toEqual(['appview'])
-  })
-})