@atproto/ozone 0.1.25 → 0.1.27

package/tests/get-config.test.ts

@@ -1,5 +1,6 @@
 import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
 import AtpAgent from '@atproto/api'
+import { TOOLS_OZONE_TEAM } from '../src/lexicon'
 
 describe('get-config', () => {
   let network: TestNetwork
@@ -39,14 +40,12 @@ describe('get-config', () => {
     )
     expect(moderatorConfig.chat?.url).toBe(undefined)
     expect(moderatorConfig.viewer?.role).toEqual(
-      'tools.ozone.moderator.defs#modRoleModerator',
+      TOOLS_OZONE_TEAM.DefsRoleModerator,
     )
   })
 
   it('returns the right role for the viewer', async () => {
     const adminConfig = await getConfig('admin')
-    expect(adminConfig.viewer?.role).toBe(
-      'tools.ozone.moderator.defs#modRoleAdmin',
-    )
+    expect(adminConfig.viewer?.role).toBe(TOOLS_OZONE_TEAM.DefsRoleAdmin)
   })
 })

package/tests/get-starter-pack.test.ts

@@ -0,0 +1,104 @@
+import {
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+  TestOzone,
+  RecordRef,
+} from '@atproto/dev-env'
+import AtpAgent from '@atproto/api'
+import { forSnapshot } from './_util'
+import { TAKEDOWN_LABEL } from '../src/mod-service'
+
+describe('admin get starter pack view', () => {
+  let network: TestNetwork
+  let ozone: TestOzone
+  let agent: AtpAgent
+  let sc: SeedClient
+  let sp1: RecordRef
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_admin_get_starterpack',
+    })
+    ozone = network.ozone
+    AtpAgent.configure({ appLabelers: [ozone.ctx.cfg.service.did] })
+    agent = ozone.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  beforeAll(async () => {
+    const feedgen = await sc.createFeedGen(
+      sc.dids.alice,
+      'did:web:example.com',
+      "alice's feedgen",
+    )
+    sp1 = await sc.createStarterPack(
+      sc.dids.alice,
+      "alice's starter pack",
+      [sc.dids.bob, sc.dids.carol, sc.dids.dan],
+      [feedgen.uriStr],
+    )
+    await network.processAll()
+  })
+
+  describe('getStarterPack()', () => {
+    it('gets a starterpack by uri', async () => {
+      const result = await agent.api.app.bsky.graph.getStarterPack(
+        { starterPack: sp1.uriStr },
+        { headers: await ozone.modHeaders() },
+      )
+      expect(forSnapshot(result.data)).toMatchSnapshot()
+    })
+
+    it('gets a starterpack while taken down', async () => {
+      // Validate that appview returns starterpacks before takedown
+      const appviewAgent = network.bsky.getClient()
+      const beforeTakedownFromAppview =
+        await appviewAgent.api.app.bsky.graph.getStarterPack(
+          { starterPack: sp1.uriStr },
+          { headers: await network.serviceHeaders(sc.dids.alice) },
+        )
+
+      expect(
+        forSnapshot(beforeTakedownFromAppview.data.starterPack),
+      ).toMatchSnapshot()
+
+      await network.bsky.db.db
+        .insertInto('label')
+        .values({
+          src: ozone.ctx.cfg.service.did,
+          uri: sp1.uriStr,
+          cid: sp1.cidStr,
+          val: TAKEDOWN_LABEL,
+          neg: false,
+          cts: new Date().toISOString(),
+        })
+        .execute()
+
+      const afterTakedownFromOzone =
+        await agent.api.app.bsky.graph.getStarterPack(
+          { starterPack: sp1.uriStr },
+          { headers: await ozone.modHeaders() },
+        )
+
+      // validate that ozone returns starterpacks after takedown
+      expect(
+        forSnapshot(afterTakedownFromOzone.data.starterPack),
+      ).toMatchSnapshot()
+
+      // validate that appview does not return starterpack after takedown
+      await expect(
+        appviewAgent.api.app.bsky.graph.getStarterPack(
+          { starterPack: sp1.uriStr },
+          { headers: await network.serviceHeaders(sc.dids.alice) },
+        ),
+      ).rejects.toThrow('Starter pack not found')
+    })
+  })
+})

package/tests/server.test.ts

@@ -54,7 +54,7 @@ describe('server', () => {
   })
 
   it('healthcheck fails when database is unavailable.', async () => {
-    // destory sequencer to release connection that would prevent the db from closing
+    // destroy sequencer to release connection that would prevent the db from closing
     await ozone.ctx.sequencer.destroy()
     await ozone.ctx.db.close()
     let error: AxiosError

package/tests/team.test.ts

@@ -0,0 +1,163 @@
+import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
+import AtpAgent from '@atproto/api'
+import { forSnapshot } from './_util'
+
+describe('team management', () => {
+  let network: TestNetwork
+  let adminAgent: AtpAgent
+  let triageAgent: AtpAgent
+  let sc: SeedClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_team_test',
+    })
+    adminAgent = network.pds.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+
+    await network.ozone.addAdminDid(sc.dids.alice)
+    await network.ozone.addModeratorDid(sc.dids.bob)
+    await network.ozone.addTriageDid(sc.dids.carol)
+    await adminAgent.login({
+      identifier: sc.accounts[sc.dids.alice].handle,
+      password: sc.accounts[sc.dids.alice].password,
+    })
+    triageAgent = network.pds.getClient()
+    await triageAgent.login({
+      identifier: sc.accounts[sc.dids.carol].handle,
+      password: sc.accounts[sc.dids.carol].password,
+    })
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('listMembers', () => {
+    it('allows all members to list all members', async () => {
+      const [{ data: forAdmin }, { data: forTriage }] = await Promise.all([
+        adminAgent.api.tools.ozone.team.listMembers({}),
+        triageAgent.api.tools.ozone.team.listMembers({}),
+      ])
+      expect(forSnapshot(forAdmin.members)).toMatchSnapshot()
+      expect(forSnapshot(forTriage.members)).toMatchSnapshot()
+      // Validate that the list looks the same to both admin and triage members
+
+      expect(forAdmin.members.length).toEqual(forTriage.members.length)
+    })
+  })
+  describe('listMembers', () => {
+    it('allows all members to list all members', async () => {
+      const [{ data: forAdmin }, { data: forTriage }] = await Promise.all([
+        adminAgent.api.tools.ozone.team.listMembers({}),
+        triageAgent.api.tools.ozone.team.listMembers({}),
+      ])
+      expect(forSnapshot(forAdmin.members)).toMatchSnapshot()
+      expect(forSnapshot(forTriage.members)).toMatchSnapshot()
+      // Validate that the list looks the same to both admin and triage members
+
+      expect(forAdmin.members.length).toEqual(forTriage.members.length)
+    })
+  })
+  describe('addMember', () => {
+    const newMemberData = {
+      did: 'did:plc:newMember',
+      role: 'tools.ozone.team.defs#roleAdmin',
+      disabled: false,
+    }
+    it('only allows admins to add member', async () => {
+      await expect(
+        triageAgent.api.tools.ozone.team.addMember(newMemberData),
+      ).rejects.toThrow('Must be an admin to add a member')
+      const { data: newMember } =
+        await adminAgent.api.tools.ozone.team.addMember(newMemberData)
+      expect(forSnapshot(newMember)).toMatchSnapshot()
+    })
+    it('throws error when trying to add existing member', async () => {
+      await expect(
+        adminAgent.api.tools.ozone.team.addMember(newMemberData),
+      ).rejects.toThrow('member already exists')
+    })
+  })
+  describe('deleteMember', () => {
+    it('only allows admins to delete members', async () => {
+      const {
+        data: { members: initialMembers },
+      } = await adminAgent.api.tools.ozone.team.listMembers({})
+      await expect(
+        triageAgent.api.tools.ozone.team.deleteMember({
+          did: sc.dids.bob,
+        }),
+      ).rejects.toThrow('Must be an admin to delete a member')
+
+      await adminAgent.api.tools.ozone.team.deleteMember({
+        did: sc.dids.bob,
+      })
+      const {
+        data: { members: membersAfterDelete },
+      } = await adminAgent.api.tools.ozone.team.listMembers({})
+
+      expect(membersAfterDelete.length).toEqual(initialMembers.length - 1)
+      expect(membersAfterDelete.map(({ did }) => did)).not.toContain(
+        sc.dids.bob,
+      )
+    })
+
+    it('throws error when trying to remove non-existent member', async () => {
+      await expect(
+        adminAgent.api.tools.ozone.team.deleteMember({
+          did: 'did:plc:test',
+        }),
+      ).rejects.toThrow('member not found')
+    })
+  })
+  describe('updateMember', () => {
+    it('allows admins to update member', async () => {
+      const getCarol = async () => {
+        const {
+          data: { members },
+        } = await adminAgent.api.tools.ozone.team.listMembers({})
+
+        return members.find(({ did }) => did === sc.dids.carol)
+      }
+      await expect(
+        triageAgent.api.tools.ozone.team.updateMember({
+          disabled: false,
+          did: sc.dids.carol,
+          role: 'tools.ozone.team.defs#roleAdmin',
+        }),
+      ).rejects.toThrow('Must be an admin to update a member')
+
+      await adminAgent.api.tools.ozone.team.updateMember({
+        did: sc.dids.carol,
+        role: 'tools.ozone.team.defs#roleAdmin',
+      })
+      const carolAfterRoleChange = await getCarol()
+      expect(carolAfterRoleChange?.role).toEqual(
+        'tools.ozone.team.defs#roleAdmin',
+      )
+      // Verify that params that we didn't send did not get updated
+      expect(carolAfterRoleChange?.disabled).toEqual(false)
+
+      await adminAgent.api.tools.ozone.team.updateMember({
+        did: sc.dids.carol,
+        disabled: true,
+      })
+      const carolAfterDisable = await getCarol()
+      expect(carolAfterDisable?.disabled).toEqual(true)
+      // Verify that params that we didn't send did not get updated
+      expect(carolAfterDisable?.role).toEqual('tools.ozone.team.defs#roleAdmin')
+    })
+    it('throws error when trying to update non-existent member', async () => {
+      await expect(
+        adminAgent.api.tools.ozone.team.updateMember({
+          disabled: false,
+          did: 'did:plc:test',
+          role: 'tools.ozone.team.defs#roleAdmin',
+        }),
+      ).rejects.toThrow('member not found')
+    })
+  })
+})