@atproto/ozone 0.2.8 → 0.2.11

package/tests/content-tagger.test.ts

@@ -1,170 +0,0 @@
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { REASONMISLEADING } from '../dist/lexicon/types/com/atproto/moderation/defs.js'
-import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs.js'
-
-describe('moderation subject content tagging', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_content_tagger_test',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const getStatus = async (subject: string) => {
-    const { subjectStatuses } = await modClient.queryStatuses({
-      subject,
-    })
-
-    return subjectStatuses[0]
-  }
-
-  describe('lang tagger', () => {
-    it('Adds language tag to post from text', async () => {
-      const createPostAndReport = async (text: string) => {
-        const post = await sc.post(sc.dids.carol, text)
-        await network.processAll()
-        const report = await sc.createReport({
-          reasonType: REASONSPAM,
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: post.ref.uriStr,
-            cid: post.ref.cidStr,
-          },
-          reportedBy: sc.dids.alice,
-        })
-
-        return { post, report }
-      }
-      const [japanesePost, greekPost] = await Promise.all([
-        createPostAndReport('Xで有名な人達＋反AIや絵描きによくない'),
-        createPostAndReport(
-          'Λορεμ ιπσθμ δολορ σιτ αμετ, μει θτ vιδιτ νοστρθμ προπριαε',
-        ),
-      ])
-
-      const [japanesePostStatus, greekPostStatus] = await Promise.all([
-        getStatus(japanesePost.post.ref.uriStr),
-        getStatus(greekPost.post.ref.uriStr),
-      ])
-
-      expect(japanesePostStatus.tags).toContain('lang:ja')
-      expect(greekPostStatus.tags).toContain('lang:el')
-    })
-
-    it('Uses name/description text for language tag for list', async () => {
-      const createListAndReport = async (
-        name: string,
-        description?: string,
-      ) => {
-        const list = await sc.createList(sc.dids.carol, name, 'mod', {
-          description,
-        })
-        await network.processAll()
-        const report = await sc.createReport({
-          reasonType: REASONSPAM,
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: list.uriStr,
-            cid: list.cidStr,
-          },
-          reportedBy: sc.dids.alice,
-        })
-        return { list, report }
-      }
-
-      const [listWithDescription, listWithoutDescription] = await Promise.all([
-        createListAndReport(
-          'よくない',
-          'Xで有名な人達＋反AIや絵描きによくない感情を持つ人達＋絵描き詐称',
-        ),
-        createListAndReport('人達＋反AIや絵描きによくない感情'),
-      ])
-
-      const [japaneseListStatus, chineseListStatus] = await Promise.all([
-        getStatus(listWithDescription.list.uriStr),
-        getStatus(listWithoutDescription.list.uriStr),
-      ])
-
-      expect(japaneseListStatus.tags).toContain('lang:ja')
-      expect(chineseListStatus.tags).toContain('lang:ja')
-    })
-  })
-
-  describe('embed tagger', () => {
-    it('Adds image tag to post with image', async () => {
-      const postWithImageMediaEmbed = sc.posts[sc.dids.carol][0]
-      const postWithImageEmbed = sc.replies[sc.dids.bob][0]
-      await Promise.all([
-        sc.createReport({
-          reasonType: REASONSPAM,
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: postWithImageMediaEmbed.ref.uriStr,
-            cid: postWithImageMediaEmbed.ref.cidStr,
-          },
-          reportedBy: sc.dids.alice,
-        }),
-        sc.createReport({
-          reasonType: REASONSPAM,
-          subject: {
-            $type: 'com.atproto.repo.strongRef',
-            uri: postWithImageEmbed.ref.uriStr,
-            cid: postWithImageEmbed.ref.cidStr,
-          },
-          reportedBy: sc.dids.alice,
-        }),
-      ])
-
-      const [mediaImagePostStatus, imagePostStatus] = await Promise.all([
-        getStatus(postWithImageMediaEmbed.ref.uriStr),
-        getStatus(postWithImageEmbed.ref.uriStr),
-      ])
-      expect(mediaImagePostStatus.tags).toContain('embed:image')
-      expect(imagePostStatus.tags).toContain('embed:image')
-    })
-  })
-
-  describe('report tagger', () => {
-    it('Adds report reason tag', async () => {
-      await Promise.all([
-        sc.createReport({
-          reasonType: REASONSPAM,
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-          reportedBy: sc.dids.alice,
-        }),
-        sc.createReport({
-          reasonType: REASONMISLEADING,
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-          reportedBy: sc.dids.alice,
-        }),
-      ])
-
-      const accountStatus = await getStatus(sc.dids.carol)
-
-      expect(accountStatus.tags).toContain('report:spam')
-      expect(accountStatus.tags).toContain('report:misleading')
-    })
-  })
-})

package/tests/db.test.ts

@@ -1,184 +0,0 @@
-import { sql } from 'kysely'
-import { wait } from '@atproto/common'
-import { TestNetwork } from '@atproto/dev-env'
-import { Database } from '../src/index.js'
-
-describe('db', () => {
-  let network: TestNetwork
-  let db: Database
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_db',
-    })
-    db = network.ozone.ctx.db
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('handles client errors without crashing.', async () => {
-    const tryKillConnection = db.transaction(async (dbTxn) => {
-      const result = await sql`select pg_backend_pid() as pid;`.execute(
-        dbTxn.db,
-      )
-      const pid = result.rows[0]?.['pid'] as number
-      await sql`select pg_terminate_backend(${pid});`.execute(db.db)
-      await sql`select 1;`.execute(dbTxn.db)
-    })
-    // This should throw, but no unhandled error
-    await expect(tryKillConnection).rejects.toThrow()
-  })
-
-  it('handles pool errors without crashing.', async () => {
-    const conn1 = await db.pool.connect()
-    const conn2 = await db.pool.connect()
-    const result = await conn1.query('select pg_backend_pid() as pid;')
-    const conn1pid: number = result.rows[0].pid
-    conn1.release()
-    await wait(100) // let release apply, conn is now idle on pool.
-    await conn2.query(`select pg_terminate_backend(${conn1pid});`)
-    conn2.release()
-  })
-
-  describe('transaction()', () => {
-    it('commits changes', async () => {
-      const result = await db.transaction(async (dbTxn) => {
-        return await dbTxn.db
-          .insertInto('repo_push_event')
-          .values({
-            eventType: 'pds_takedown',
-            subjectDid: 'x',
-          })
-          .returning('subjectDid')
-          .executeTakeFirst()
-      })
-
-      if (!result) {
-        return expect(result).toBeTruthy()
-      }
-
-      expect(result.subjectDid).toEqual('x')
-
-      const row = await db.db
-        .selectFrom('repo_push_event')
-        .selectAll()
-        .where('subjectDid', '=', 'x')
-        .executeTakeFirst()
-
-      expect(row).toMatchObject({
-        eventType: 'pds_takedown',
-        subjectDid: 'x',
-      })
-    })
-
-    it('rolls-back changes on failure', async () => {
-      const promise = db.transaction(async (dbTxn) => {
-        await dbTxn.db
-          .insertInto('repo_push_event')
-          .values({
-            eventType: 'pds_takedown',
-            subjectDid: 'y',
-          })
-          .returning('subjectDid')
-          .executeTakeFirst()
-
-        throw new Error('Oops!')
-      })
-
-      await expect(promise).rejects.toThrow('Oops!')
-
-      const row = await db.db
-        .selectFrom('repo_push_event')
-        .selectAll()
-        .where('subjectDid', '=', 'y')
-        .executeTakeFirst()
-
-      expect(row).toBeUndefined()
-    })
-
-    it('indicates isTransaction', async () => {
-      expect(db.isTransaction).toEqual(false)
-
-      await db.transaction(async (dbTxn) => {
-        expect(db.isTransaction).toEqual(false)
-        expect(dbTxn.isTransaction).toEqual(true)
-      })
-
-      expect(db.isTransaction).toEqual(false)
-    })
-
-    it('asserts transaction', async () => {
-      expect(() => db.assertTransaction()).toThrow('Transaction required')
-
-      await db.transaction(async (dbTxn) => {
-        expect(() => dbTxn.assertTransaction()).not.toThrow()
-      })
-    })
-
-    it('does not allow leaky transactions', async () => {
-      let leakedTx: Database | undefined
-
-      const tx = db.transaction(async (dbTxn) => {
-        leakedTx = dbTxn
-        await dbTxn.db
-          .insertInto('repo_push_event')
-          .values({ eventType: 'pds_takedown', subjectDid: 'a' })
-          .execute()
-        throw new Error('test tx failed')
-      })
-      await expect(tx).rejects.toThrow('test tx failed')
-
-      const attempt = leakedTx?.db
-        .insertInto('repo_push_event')
-        .values({ eventType: 'pds_takedown', subjectDid: 'b' })
-        .execute()
-      await expect(attempt).rejects.toThrow('tx already failed')
-
-      const res = await db.db
-        .selectFrom('repo_push_event')
-        .selectAll()
-        .where('subjectDid', 'in', ['a', 'b'])
-        .execute()
-
-      expect(res.length).toBe(0)
-    })
-
-    it('ensures all inflight queries are rolled back', async () => {
-      let promise: Promise<unknown> | undefined = undefined
-      const names: string[] = []
-      try {
-        await db.transaction(async (dbTxn) => {
-          const queries: Promise<unknown>[] = []
-          for (let i = 0; i < 20; i++) {
-            const name = `user${i}`
-            const query = dbTxn.db
-              .insertInto('repo_push_event')
-              .values({
-                eventType: 'pds_takedown',
-                subjectDid: name,
-              })
-              .execute()
-            names.push(name)
-            queries.push(query)
-          }
-          promise = Promise.allSettled(queries)
-          throw new Error()
-        })
-      } catch (err) {
-        expect(err).toBeDefined()
-      }
-      if (promise) {
-        await promise
-      }
-
-      const res = await db.db
-        .selectFrom('repo_push_event')
-        .selectAll()
-        .where('subjectDid', 'in', names)
-        .execute()
-      expect(res.length).toBe(0)
-    })
-  })
-})

package/tests/expiring-label.test.ts

@@ -1,72 +0,0 @@
-import AtpAgent from '@atproto/api'
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-
-describe('expiring label', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-  let agent: AtpAgent
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_expiring_label_test',
-    })
-    sc = network.getSeedClient()
-    agent = network.ozone.getAgent()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const emitExpiringLabel = async (did: string) =>
-    modClient.emitEvent(
-      {
-        subject: { $type: 'com.atproto.admin.defs#repoRef', did },
-        event: {
-          $type: 'tools.ozone.moderation.defs#modEventLabel',
-          comment: 'Testing expiring label',
-          createLabelVals: ['expiring'],
-          negateLabelVals: [],
-          durationInHours: 1,
-        },
-        createdBy: sc.dids.alice,
-      },
-      'moderator',
-    )
-
-  it('Returns expiring label only within expiration period', async () => {
-    const getRepo = async (did: string) =>
-      agent.tools.ozone.moderation.getRepo(
-        { did },
-        {
-          headers: await network.ozone.modHeaders(
-            ids.ToolsOzoneModerationGetRepo,
-          ),
-        },
-      )
-
-    const now = new Date().toISOString()
-    await emitExpiringLabel(sc.dids.carol)
-    const { data: repoWithExpiringLabel } = await getRepo(sc.dids.carol)
-    expect(repoWithExpiringLabel.labels?.[0].val).toEqual('expiring')
-    // Manually expire the label in db
-    await network.ozone.ctx.db.db
-      .updateTable('label')
-      .set({ exp: now })
-      .where('uri', '=', sc.dids.carol)
-      .execute()
-
-    const { data: repoAfterExpiringLabel } = await getRepo(sc.dids.carol)
-    expect(repoAfterExpiringLabel.labels?.length).toEqual(0)
-  })
-})

package/tests/expiring-tags.test.ts

@@ -1,232 +0,0 @@
-import {
-  ModeratorClient,
-  SeedClient,
-  TestNetwork,
-  basicSeed,
-} from '@atproto/dev-env'
-import { EventReverser } from '../src/daemon/event-reverser.js'
-import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs.js'
-
-describe('expiring tags', () => {
-  let network: TestNetwork
-  let sc: SeedClient
-  let modClient: ModeratorClient
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_expiring_tags',
-    })
-    sc = network.getSeedClient()
-    modClient = network.ozone.getModClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  const emitTagEvent = (
-    did: string,
-    add: string[],
-    remove: string[],
-    durationInHours?: number,
-  ) =>
-    modClient.emitEvent({
-      subject: { $type: 'com.atproto.admin.defs#repoRef', did },
-      event: {
-        $type: 'tools.ozone.moderation.defs#modEventTag',
-        add,
-        remove,
-        ...(durationInHours !== undefined ? { durationInHours } : {}),
-      },
-    })
-
-  const getSubjectTags = async (did: string): Promise<string[]> => {
-    const result = await modClient.queryStatuses({ subject: did })
-    return result.subjectStatuses[0]?.tags ?? []
-  }
-
-  const createReverser = () =>
-    new EventReverser(
-      network.ozone.ctx.db,
-      // @ts-expect-error Error due to circular dependency with the dev-env package
-      network.ozone.ctx.modService,
-    )
-
-  it('creates expiring_tag rows when durationInHours is set', async () => {
-    // Create a report so the subject exists in moderation_subject_status
-    await sc.createReport({
-      reasonType: REASONSPAM,
-      reason: 'test',
-      subject: { $type: 'com.atproto.admin.defs#repoRef', did: sc.dids.bob },
-      reportedBy: sc.dids.alice,
-    })
-
-    await emitTagEvent(sc.dids.bob, ['temp-tag-1', 'temp-tag-2'], [], 1)
-
-    const tags = await getSubjectTags(sc.dids.bob)
-    expect(tags).toContain('temp-tag-1')
-    expect(tags).toContain('temp-tag-2')
-
-    // Verify expiring_tag rows were created
-    const expiringRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.bob)
-      .selectAll()
-      .execute()
-
-    expect(expiringRows).toHaveLength(2)
-    expect(expiringRows.map((r) => r.tag).sort()).toEqual([
-      'temp-tag-1',
-      'temp-tag-2',
-    ])
-    expect(expiringRows[0].expiresAt).toBeTruthy()
-  })
-
-  it('does not create expiring_tag rows without durationInHours', async () => {
-    await emitTagEvent(sc.dids.bob, ['permanent-tag'], [])
-
-    const tags = await getSubjectTags(sc.dids.bob)
-    expect(tags).toContain('permanent-tag')
-
-    const expiringRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.bob)
-      .where('tag', '=', 'permanent-tag')
-      .selectAll()
-      .execute()
-
-    expect(expiringRows).toHaveLength(0)
-  })
-
-  it('daemon reverts expired tags', async () => {
-    // Manually expire the tags in the DB
-    await network.ozone.ctx.db.db
-      .updateTable('expiring_tag')
-      .set({ expiresAt: new Date(Date.now() - 1000).toISOString() })
-      .where('did', '=', sc.dids.bob)
-      .execute()
-
-    const reverser = createReverser()
-    await reverser.findAndRevertDueActions()
-
-    const tags = await getSubjectTags(sc.dids.bob)
-    expect(tags).not.toContain('temp-tag-1')
-    expect(tags).not.toContain('temp-tag-2')
-    // Permanent tag should still be there
-    expect(tags).toContain('permanent-tag')
-
-    // Verify expiring_tag rows are cleaned up
-    const remainingRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.bob)
-      .selectAll()
-      .execute()
-
-    expect(remainingRows).toHaveLength(0)
-  })
-
-  it('daemon emits a modEventTag removal event', async () => {
-    const events = await modClient.queryEvents({
-      subject: sc.dids.bob,
-      types: ['tools.ozone.moderation.defs#modEventTag'],
-    })
-
-    const lastTagEvent = events.events[0]
-    expect(lastTagEvent.event).toMatchObject({
-      $type: 'tools.ozone.moderation.defs#modEventTag',
-      add: [],
-      remove: expect.arrayContaining(['temp-tag-1', 'temp-tag-2']),
-      comment:
-        '[SCHEDULED_REVERSAL] Reverting temporary tags as originally scheduled',
-    })
-  })
-
-  it('cleans up expiring_tag rows when tags are manually removed', async () => {
-    await sc.createReport({
-      reasonType: REASONSPAM,
-      reason: 'test',
-      subject: {
-        $type: 'com.atproto.admin.defs#repoRef',
-        did: sc.dids.carol,
-      },
-      reportedBy: sc.dids.alice,
-    })
-
-    await emitTagEvent(sc.dids.carol, ['auto-remove-tag'], [], 24)
-
-    // Verify the expiring_tag row exists
-    let expiringRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.carol)
-      .where('tag', '=', 'auto-remove-tag')
-      .selectAll()
-      .execute()
-    expect(expiringRows).toHaveLength(1)
-
-    // Manually remove the tag
-    await emitTagEvent(sc.dids.carol, [], ['auto-remove-tag'])
-
-    // Verify the expiring_tag row is cleaned up
-    expiringRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.carol)
-      .where('tag', '=', 'auto-remove-tag')
-      .selectAll()
-      .execute()
-    expect(expiringRows).toHaveLength(0)
-  })
-
-  it('daemon skips tags already manually removed', async () => {
-    await emitTagEvent(sc.dids.carol, ['skip-tag'], [], 1)
-
-    // Manually remove the tag first
-    await emitTagEvent(sc.dids.carol, [], ['skip-tag'])
-
-    // Re-insert an expiring_tag row to simulate the race condition
-    // (row wasn't cleaned up for some reason)
-    await network.ozone.ctx.db.db
-      .insertInto('expiring_tag')
-      .values({
-        eventId: 0,
-        did: sc.dids.carol,
-        recordPath: '',
-        convoId: '',
-        tag: 'skip-tag',
-        expiresAt: new Date(Date.now() - 1000).toISOString(),
-        createdBy: sc.dids.alice,
-      })
-      .execute()
-
-    const tagsBefore = await getSubjectTags(sc.dids.carol)
-    expect(tagsBefore).not.toContain('skip-tag')
-
-    const reverser = createReverser()
-    await reverser.findAndRevertDueActions()
-
-    // Verify no removal event was emitted for a tag that's already gone
-    const events = await modClient.queryEvents({
-      subject: sc.dids.carol,
-      types: ['tools.ozone.moderation.defs#modEventTag'],
-    })
-
-    // The last tag event should be the manual removal, not a scheduled reversal
-    const lastEvent = events.events[0]
-    expect(lastEvent.event).toMatchObject({
-      $type: 'tools.ozone.moderation.defs#modEventTag',
-      remove: ['skip-tag'],
-    })
-    const comment = (lastEvent.event as { comment?: string }).comment ?? ''
-    expect(comment).not.toContain('SCHEDULED_REVERSAL')
-
-    // Verify the expiring_tag row is still cleaned up
-    const remainingRows = await network.ozone.ctx.db.db
-      .selectFrom('expiring_tag')
-      .where('did', '=', sc.dids.carol)
-      .where('tag', '=', 'skip-tag')
-      .selectAll()
-      .execute()
-    expect(remainingRows).toHaveLength(0)
-  })
-})