@atproto/ozone 0.2.9 → 0.2.11

package/tests/sets.test.ts

@@ -1,246 +0,0 @@
-import AtpAgent, {
-  ToolsOzoneSetDefs,
-  ToolsOzoneSetQuerySets,
-} from '@atproto/api'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { ids } from '../src/lexicon/lexicons.js'
-import { forSnapshot } from './_util.js'
-
-describe('ozone-sets', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  const sampleSet1 = {
-    name: 'test-set-1',
-    description: 'Test set 1',
-  }
-
-  const sampleSet2 = {
-    name: 'test-set-2',
-  }
-
-  const sampleSet3 = {
-    name: 'another-set',
-    description: 'Another test set',
-  }
-
-  const upsertSet = async (set: ToolsOzoneSetDefs.Set) => {
-    const { data } = await agent.tools.ozone.set.upsertSet(set, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneSetUpsertSet,
-        'admin',
-      ),
-    })
-
-    return data
-  }
-
-  const removeSet = async (name: string) => {
-    await agent.tools.ozone.set.deleteSet(
-      { name },
-      {
-        encoding: 'application/json',
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneSetDeleteSet,
-          'admin',
-        ),
-      },
-    )
-  }
-
-  const addValues = async (name: string, values: string[]) => {
-    await agent.tools.ozone.set.addValues(
-      { name, values },
-      {
-        encoding: 'application/json',
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneSetAddValues,
-          'admin',
-        ),
-      },
-    )
-  }
-
-  const getValues = async (name: string, limit?: number, cursor?: string) => {
-    const { data } = await agent.tools.ozone.set.getValues(
-      { name, limit, cursor },
-      {
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneSetGetValues,
-          'moderator',
-        ),
-      },
-    )
-    return data
-  }
-
-  const querySets = async (params: ToolsOzoneSetQuerySets.QueryParams) => {
-    const { data } = await agent.tools.ozone.set.querySets(params, {
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneSetQuerySets,
-        'moderator',
-      ),
-    })
-    return data
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_sets',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  describe('querySets', () => {
-    beforeAll(async () => {
-      await Promise.all([
-        upsertSet(sampleSet1),
-        upsertSet(sampleSet2),
-        upsertSet(sampleSet3),
-      ])
-    })
-    afterAll(async () => {
-      await Promise.all([
-        removeSet(sampleSet1.name),
-        removeSet(sampleSet2.name),
-        removeSet(sampleSet3.name),
-      ])
-    })
-    it('returns all sets when no parameters are provided', async () => {
-      const result = await querySets({})
-      expect(result.sets.length).toBe(3)
-      expect(forSnapshot(result.sets)).toMatchSnapshot()
-    })
-
-    it('limits the number of returned sets', async () => {
-      const result = await querySets({ limit: 2 })
-      expect(result.sets.length).toBe(2)
-      expect(result.cursor).toBeDefined()
-    })
-
-    it('returns sets after the cursor', async () => {
-      const firstPage = await querySets({ limit: 2 })
-      const secondPage = await querySets({ cursor: firstPage.cursor })
-      expect(secondPage.sets.length).toBe(1)
-      expect(secondPage.sets[0].name).toBe('test-set-2')
-    })
-
-    it('filters sets by name prefix', async () => {
-      const result = await querySets({ namePrefix: 'test-' })
-      expect(result.sets.length).toBe(2)
-      expect(result.sets.map((s) => s.name)).toEqual([
-        'test-set-1',
-        'test-set-2',
-      ])
-    })
-
-    it('sorts sets by given column and direction', async () => {
-      const sortedByName = await querySets({ sortBy: 'name' })
-      expect(sortedByName.sets.map((s) => s.name)).toEqual([
-        'another-set',
-        'test-set-1',
-        'test-set-2',
-      ])
-      const reverseSortedByName = await querySets({
-        sortBy: 'name',
-        sortDirection: 'desc',
-      })
-      expect(reverseSortedByName.sets.map((s) => s.name)).toEqual([
-        'test-set-2',
-        'test-set-1',
-        'another-set',
-      ])
-    })
-  })
-
-  describe('upsertSet', () => {
-    afterAll(async () => {
-      await removeSet('new-test-set')
-    })
-    it('creates a new set', async () => {
-      const result = await upsertSet({
-        name: 'new-test-set',
-        description: 'A new test set',
-      })
-      expect(forSnapshot(result)).toMatchSnapshot()
-    })
-
-    it('updates an existing set', async () => {
-      const result = await upsertSet({
-        name: 'new-test-set',
-        description: 'Updated description',
-      })
-      expect(forSnapshot(result)).toMatchSnapshot()
-    })
-
-    it('allows setting empty description', async () => {
-      const result = await upsertSet({
-        name: 'new-test-set',
-        description: '',
-      })
-      expect(result.description).toBeUndefined()
-    })
-  })
-
-  describe('addValues', () => {
-    beforeAll(async () => {
-      await upsertSet(sampleSet1)
-      await upsertSet(sampleSet2)
-    })
-    afterAll(async () => {
-      await removeSet(sampleSet1.name)
-      await removeSet(sampleSet2.name)
-    })
-    it('adds new values to an existing set', async () => {
-      const newValues = ['value1', 'value2', 'value3']
-      await addValues(sampleSet1.name, newValues)
-
-      const result = await getValues(sampleSet1.name)
-      expect(result.values).toEqual(expect.arrayContaining(newValues))
-    })
-
-    it('does not duplicate existing values', async () => {
-      const initialValues = ['initial1', 'initial2']
-      await addValues(sampleSet2.name, initialValues)
-
-      const newValues = ['initial2', 'new1', 'new2']
-      await addValues(sampleSet2.name, newValues)
-
-      const result = await getValues(sampleSet2.name)
-      expect(result.values).toEqual(
-        expect.arrayContaining([...initialValues, 'new1', 'new2']),
-      )
-      expect(result.values.filter((v) => v === 'initial2').length).toBe(1)
-    })
-  })
-
-  describe('getValues', () => {
-    beforeAll(async () => {
-      await upsertSet(sampleSet1)
-    })
-    afterAll(async () => {
-      await removeSet(sampleSet1.name)
-    })
-    it('paginates values from a set', async () => {
-      const allValues = Array.from({ length: 9 }, (_, i) => `value${i}`)
-      await addValues(sampleSet1.name, allValues)
-
-      const firstPage = await getValues(sampleSet1.name, 3)
-      const secondPage = await getValues(sampleSet1.name, 3, firstPage.cursor)
-      const lastPage = await getValues(sampleSet1.name, 3, secondPage.cursor)
-
-      expect(firstPage.values).toEqual(allValues.slice(0, 3))
-      expect(secondPage.values).toEqual(allValues.slice(3, 6))
-      expect(lastPage.values).toEqual(allValues.slice(6, 9))
-    })
-  })
-})

package/tests/settings.test.ts

@@ -1,308 +0,0 @@
-import AtpAgent, {
-  ToolsOzoneSettingListOptions,
-  ToolsOzoneSettingUpsertOption,
-} from '@atproto/api'
-import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
-import { SettingScope } from '../dist/db/schema/setting.js'
-import { ids } from '../src/lexicon/lexicons.js'
-import { forSnapshot } from './_util.js'
-
-describe('ozone-settings', () => {
-  let network: TestNetwork
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  const upsertOption = async (
-    setting: ToolsOzoneSettingUpsertOption.InputSchema,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
-  ) => {
-    const { data } = await agent.tools.ozone.setting.upsertOption(setting, {
-      encoding: 'application/json',
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneSettingUpsertOption,
-        callerRole,
-      ),
-    })
-
-    return data
-  }
-
-  const removeOptions = async (
-    keys: string[],
-    scope: SettingScope,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'admin',
-  ) => {
-    await agent.tools.ozone.setting.removeOptions(
-      { keys, scope },
-      {
-        encoding: 'application/json',
-        headers: await network.ozone.modHeaders(
-          ids.ToolsOzoneSettingRemoveOptions,
-          callerRole,
-        ),
-      },
-    )
-  }
-
-  const listOptions = async (
-    params: ToolsOzoneSettingListOptions.QueryParams,
-    callerRole: 'admin' | 'moderator' | 'triage' = 'moderator',
-  ) => {
-    const { data } = await agent.tools.ozone.setting.listOptions(params, {
-      headers: await network.ozone.modHeaders(
-        ids.ToolsOzoneSettingListOptions,
-        callerRole,
-      ),
-    })
-    return data
-  }
-
-  beforeAll(async () => {
-    network = await TestNetwork.create({
-      dbPostgresSchema: 'ozone_settings',
-    })
-    agent = network.ozone.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  describe('upsertOption', () => {
-    afterAll(async () => {
-      await removeOptions(
-        ['tools.ozone.setting.upsertTest.labelers'],
-        'personal',
-      )
-    })
-    it('only allows managerRole to update instance settings', async () => {
-      await upsertOption({
-        scope: 'instance',
-        key: 'tools.ozone.setting.upsertTest.labelers',
-        value: { dids: ['did:plc:xyz'] },
-        description: 'triage users can not update this',
-        managerRole: 'tools.ozone.team.defs#roleModerator',
-      })
-
-      await expect(
-        upsertOption(
-          {
-            scope: 'instance',
-            key: 'tools.ozone.setting.upsertTest.labelers',
-            value: { noDids: 'test' },
-            description: 'triage users can not update this',
-            managerRole: 'tools.ozone.team.defs#roleModerator',
-          },
-          'triage',
-        ),
-      ).rejects.toThrow(/Not permitted/gi)
-
-      await upsertOption(
-        {
-          scope: 'instance',
-          key: 'tools.ozone.setting.upsertTest.labelers',
-          value: { noDids: 'test' },
-          description:
-            'My personal labelers that i want to use when browsing ozone',
-          managerRole: 'tools.ozone.team.defs#roleModerator',
-        },
-        'moderator',
-      )
-
-      const afterUpdatedByModerator = await listOptions(
-        {
-          scope: 'instance',
-          prefix: 'tools.ozone.setting.upsertTest.labelers',
-        },
-        'moderator',
-      )
-      expect(afterUpdatedByModerator.options[0].value?.['dids']).toBeFalsy()
-      expect(afterUpdatedByModerator.options[0].value?.['noDids']).toEqual(
-        'test',
-      )
-      await upsertOption(
-        {
-          scope: 'instance',
-          key: 'tools.ozone.setting.upsertTest.labelers',
-          value: { dids: 'test' },
-          description:
-            'My personal labelers that i want to use when browsing ozone',
-          managerRole: 'tools.ozone.team.defs#roleModerator',
-        },
-        'moderator',
-      )
-
-      const afterUpdatedByAdmin = await listOptions(
-        {
-          scope: 'instance',
-          prefix: 'tools.ozone.setting.upsertTest.labelers',
-        },
-        'admin',
-      )
-      expect(afterUpdatedByAdmin.options[0].value?.['noDids']).toBeFalsy()
-      expect(afterUpdatedByAdmin.options[0].value?.['dids']).toEqual('test')
-    })
-  })
-
-  describe('listOptions', () => {
-    beforeAll(async () => {
-      await upsertOption({
-        scope: 'instance',
-        key: 'tools.ozone.setting.client.queues',
-        value: { stratosphere: { name: 'Stratosphere' } },
-        description:
-          'This determines how many queues the client interface will show',
-        managerRole: 'tools.ozone.team.defs#roleAdmin',
-      })
-      await upsertOption({
-        scope: 'instance',
-        key: 'tools.ozone.setting.client.queueHash',
-        value: { val: 10.5 },
-        description:
-          'This determines how each queue is balanced when sorted by oldest first',
-        managerRole: 'tools.ozone.team.defs#roleAdmin',
-      })
-      await upsertOption({
-        scope: 'instance',
-        key: 'tools.ozone.setting.client.externalLabelers',
-        value: { dids: ['did:plc:xyz'] },
-        description:
-          'List of external labelers that will be plugged into the client views',
-        managerRole: 'tools.ozone.team.defs#roleAdmin',
-      })
-    })
-
-    afterAll(async () => {
-      await removeOptions(
-        [
-          'tools.ozone.setting.client.queues',
-          'tools.ozone.setting.client.queueHash',
-          'tools.ozone.setting.client.externalLabelers',
-        ],
-        'instance',
-      )
-    })
-
-    it('returns all personal settings', async () => {
-      const result = await listOptions({ prefix: 'tools.ozone.setting.client' })
-      expect(result.options.length).toBe(3)
-
-      expect(forSnapshot(result.options)).toMatchSnapshot()
-    })
-
-    it('allows paginating options', async () => {
-      const params = { prefix: 'tools.ozone.setting.client', limit: 1 }
-      const pageOne = await listOptions(params)
-      const pageTwo = await listOptions({
-        ...params,
-        cursor: pageOne.cursor,
-      })
-      const pageThree = await listOptions({
-        ...params,
-        cursor: pageTwo.cursor,
-      })
-      const pageFour = await listOptions({
-        ...params,
-        cursor: pageThree.cursor,
-      })
-
-      expect(pageFour.options.length).toBe(0)
-      expect(pageFour.cursor).toBeUndefined()
-    })
-  })
-
-  describe('removeOptions', () => {
-    afterAll(async () => {
-      await Promise.all([
-        removeOptions(['tools.ozone.setting.personal.labelers'], 'personal'),
-        removeOptions(
-          ['tools.ozone.setting.only.mod', 'tools.ozone.setting.only.admin'],
-          'instance',
-        ),
-      ])
-    })
-
-    it('only allows the owner to delete personal setting', async () => {
-      await upsertOption({
-        scope: 'personal',
-        key: 'tools.ozone.setting.personal.labelers',
-        value: { dids: ['did:plc:xyz'] },
-        description:
-          'My personal labelers that i want to use when browsing ozone',
-        managerRole: 'tools.ozone.team.defs#roleOwner',
-      })
-
-      // one user can't remove personal setting of another
-      await removeOptions(
-        ['tools.ozone.setting.personal.labelers'],
-        'personal',
-        'triage',
-      )
-      const list = await listOptions({ scope: 'personal' }, 'admin')
-      expect(list.options.length).toBe(1)
-
-      // the owner of the personal setting can remove their own setting
-      await removeOptions(['tools.ozone.setting.personal.labelers'], 'personal')
-      const listAfterRemoval = await listOptions({ scope: 'personal' }, 'admin')
-      expect(listAfterRemoval.options.length).toBe(0)
-    })
-
-    it('only allows managerRole to delete instance setting', async () => {
-      await Promise.all([
-        upsertOption({
-          scope: 'instance',
-          key: 'tools.ozone.setting.only.mod',
-          value: { dids: ['did:plc:xyz'] },
-          description: 'Triage mods can not manage these',
-          managerRole: 'tools.ozone.team.defs#roleModerator',
-        }),
-        upsertOption({
-          scope: 'instance',
-          key: 'tools.ozone.setting.only.admin',
-          value: { dids: ['did:plc:xyz'] },
-          description: 'Moderators or triage mods can not manage these',
-          managerRole: 'tools.ozone.team.defs#roleAdmin',
-        }),
-      ])
-
-      await Promise.all([
-        removeOptions(['tools.ozone.setting.only.mod'], 'instance', 'triage'),
-        removeOptions(
-          ['tools.ozone.setting.only.admin'],
-          'instance',
-          'moderator',
-        ),
-        removeOptions(['tools.ozone.setting.only.admin'], 'instance', 'triage'),
-      ])
-
-      const afterFailedAttempt = await listOptions(
-        { scope: 'instance', prefix: 'tools.ozone.setting.only' },
-        'admin',
-      )
-      const keysAfterFailedAttempt = afterFailedAttempt.options.map(
-        (o) => o.key,
-      )
-
-      const keys = [
-        'tools.ozone.setting.only.mod',
-        'tools.ozone.setting.only.admin',
-      ]
-
-      keys.forEach((key) => expect(keysAfterFailedAttempt).toContain(key))
-
-      await Promise.all([
-        removeOptions(['tools.ozone.setting.only.mod'], 'instance', 'admin'),
-        removeOptions(['tools.ozone.setting.only.admin'], 'instance', 'admin'),
-      ])
-
-      const afterRemoval = await listOptions(
-        { scope: 'instance', prefix: 'tools.ozone.setting.only' },
-        'admin',
-      )
-      expect(afterRemoval.options.length).toBe(0)
-    })
-  })
-})