@evanp/activitypub-bot 0.9.0 → 0.12.0

package/tests/keystorage.test.js

@@ -3,6 +3,7 @@ import { KeyStorage } from '../lib/keystorage.js'
 import assert from 'node:assert'
 import { Sequelize } from 'sequelize'
 import Logger from 'pino'
+import { runMigrations } from '../lib/migrations/index.js'
 
 describe('KeyStorage', async () => {
   let connection = null
@@ -12,9 +13,14 @@ describe('KeyStorage', async () => {
   let firstPrivateKey = null
   let secondPublicKey = null
   let secondPrivateKey = null
+  let firstSystemPublicKey = null
+  let firstSystemPrivateKey = null
+  let secondSystemPublicKey = null
+  let secondSystemPrivateKey = null
   before(async () => {
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     logger = new Logger({
       level: 'silent'
     })
@@ -26,7 +32,6 @@ describe('KeyStorage', async () => {
   })
   it('can initialize', async () => {
     storage = new KeyStorage(connection, logger)
-    await storage.initialize()
   })
   it('can get a public key', async () => {
     firstPublicKey = await storage.getPublicKey('test1')
@@ -86,4 +91,34 @@ describe('KeyStorage', async () => {
     assert.ok(privateKey2)
     assert.notEqual(privateKey, privateKey2)
   })
+  it('can get a system public key', async () => {
+    firstSystemPublicKey = await storage.getPublicKey(null)
+    assert.ok(firstSystemPublicKey)
+    assert.equal(typeof firstSystemPublicKey, 'string')
+    assert.match(firstSystemPublicKey, /^-----BEGIN PUBLIC KEY-----\n/)
+    assert.match(firstSystemPublicKey, /-----END PUBLIC KEY-----\n$/)
+  })
+  it('can get a system public key again', async () => {
+    secondSystemPublicKey = await storage.getPublicKey(null)
+    assert.ok(secondSystemPublicKey)
+    assert.equal(typeof secondSystemPublicKey, 'string')
+    assert.match(secondSystemPublicKey, /^-----BEGIN PUBLIC KEY-----\n/)
+    assert.match(secondSystemPublicKey, /-----END PUBLIC KEY-----\n$/)
+    assert.equal(firstSystemPublicKey, secondSystemPublicKey)
+  })
+  it('can get a system private key', async () => {
+    firstSystemPrivateKey = await storage.getPrivateKey(null)
+    assert.ok(firstSystemPrivateKey)
+    assert.equal(typeof firstSystemPrivateKey, 'string')
+    assert.match(firstSystemPrivateKey, /^-----BEGIN PRIVATE KEY-----\n/)
+    assert.match(firstSystemPrivateKey, /-----END PRIVATE KEY-----\n$/)
+  })
+  it('can get a system private key again', async () => {
+    secondSystemPrivateKey = await storage.getPrivateKey(null)
+    assert.ok(secondSystemPrivateKey)
+    assert.equal(typeof secondSystemPrivateKey, 'string')
+    assert.match(secondSystemPrivateKey, /^-----BEGIN PRIVATE KEY-----\n/)
+    assert.match(secondSystemPrivateKey, /-----END PRIVATE KEY-----\n$/)
+    assert.equal(firstSystemPrivateKey, secondSystemPrivateKey)
+  })
 })

package/tests/microsyntax.test.js

@@ -9,6 +9,7 @@ import { nockSetup } from './utils/nock.js'
 import { HTTPSignature } from '../lib/httpsignature.js'
 import Logger from 'pino'
 import { Digester } from '../lib/digester.js'
+import { runMigrations } from '../lib/migrations/index.js'
 
 const AS2 = 'https://www.w3.org/ns/activitystreams#'
 
@@ -22,10 +23,10 @@ describe('microsyntax', async () => {
     level: 'silent'
   })
   const digester = new Digester(logger)
-  const connection = new Sequelize('sqlite::memory:', { logging: false })
+  const connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
   await connection.authenticate()
+  await runMigrations(connection)
   const keyStorage = new KeyStorage(connection, logger)
-  await keyStorage.initialize()
   const formatter = new UrlFormatter(origin)
   const signer = new HTTPSignature(logger)
   const client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)

package/tests/objectstorage.test.js

@@ -3,6 +3,7 @@ import as2 from '../lib/activitystreams.js'
 import assert from 'node:assert'
 import { ObjectStorage, NoSuchObjectError } from '../lib/objectstorage.js'
 import { Sequelize } from 'sequelize'
+import { runMigrations } from '../lib/migrations/index.js'
 
 describe('ObjectStorage', async () => {
   let doc = null
@@ -33,15 +34,15 @@ describe('ObjectStorage', async () => {
       name: 'test',
       content: 'test'
     })
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
   })
   after(async () => {
     await connection.close()
   })
   it('can initialize', async () => {
     storage = new ObjectStorage(connection)
-    await storage.initialize()
   })
   it('can create a new object', async () => {
     await storage.create(doc)
@@ -59,7 +60,7 @@ describe('ObjectStorage', async () => {
     })
     await storage.update(doc2)
     const read = await storage.read(doc2.id)
-    assert.equal(read.name.get('en'), 'test2')
+    assert.equal(read.name.get(), 'test2')
   })
   it('can delete a created object', async () => {
     await storage.delete(doc)

package/tests/remotekeystorage.test.js

@@ -9,9 +9,12 @@ import { nockSetup, nockFormat, getPublicKey, nockKeyRotate } from './utils/nock
 import { HTTPSignature } from '../lib/httpsignature.js'
 import Logger from 'pino'
 import { Digester } from '../lib/digester.js'
+import { runMigrations } from '../lib/migrations/index.js'
 
 describe('RemoteKeyStorage', async () => {
-  const origin = 'https://activitypubbot.example'
+  const host = 'activitypubbot.example'
+  const remoteHost = 'social.example'
+  const origin = `https://${host}`
   let connection = null
   let remoteKeyStorage = null
   let client = null
@@ -20,15 +23,15 @@ describe('RemoteKeyStorage', async () => {
     logger = Logger({
       level: 'silent'
     })
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     const keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
     const formatter = new UrlFormatter(origin)
     const digester = new Digester(logger)
     const signer = new HTTPSignature(logger)
     client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
-    nockSetup('social.example')
+    nockSetup(remoteHost)
   })
 
   after(async () => {
@@ -39,13 +42,12 @@ describe('RemoteKeyStorage', async () => {
   it('can initialize', async () => {
     remoteKeyStorage = new RemoteKeyStorage(client, connection, logger)
     assert.ok(remoteKeyStorage)
-    await remoteKeyStorage.initialize()
     assert.ok(true)
   })
 
   it('can get a remote public key', async () => {
     const username = 'test'
-    const domain = 'social.example'
+    const domain = remoteHost
     const id = nockFormat({ username, key: true, domain })
     const publicKey = await getPublicKey(username, domain)
     const remote = await remoteKeyStorage.getPublicKey(id)
@@ -54,7 +56,7 @@ describe('RemoteKeyStorage', async () => {
 
   it('can get the same remote public key twice', async () => {
     const username = 'test'
-    const domain = 'social.example'
+    const domain = remoteHost
     const id = nockFormat({ username, key: true, domain })
     const publicKey = await getPublicKey(username, domain)
     const remote = await remoteKeyStorage.getPublicKey(id)
@@ -63,7 +65,7 @@ describe('RemoteKeyStorage', async () => {
 
   it('can get the right public key after key rotation', async () => {
     const username = 'test'
-    const domain = 'social.example'
+    const domain = remoteHost
     const id = nockFormat({ username, key: true, domain })
     const publicKey = await getPublicKey(username, domain)
     const remote = await remoteKeyStorage.getPublicKey(id)

package/tests/routes.actor.test.js

@@ -97,6 +97,12 @@ describe('actor routes', async () => {
       assert.match(response.body.publicKey.publicKeyPem, /^-----BEGIN PUBLIC KEY-----\n/)
       assert.match(response.body.publicKey.publicKeyPem, /\n-----END PUBLIC KEY-----\n$/)
     })
+    it('should include endpoints', async () => {
+      assert.strictEqual(typeof response.body.endpoints, 'object')
+    })
+    it('should include a sharedInbox endpoint', async () => {
+      assert.strictEqual(typeof response.body.endpoints.sharedInbox, 'string')
+    })
   })
 
   describe('GET non-existent user', async () => {
@@ -138,6 +144,7 @@ describe('actor routes', async () => {
       assert.strictEqual(response.body.detail, 'User dne not found')
     })
   })
+
   describe('GET /user/{dne}/publickey', async () => {
     let response = null
     it('should work without an error', async () => {

package/tests/routes.collection.test.js

@@ -26,7 +26,6 @@ describe('actor collection routes', async () => {
         })
         it('should return an object', async () => {
           assert.strictEqual(typeof response.body, 'object')
-          console.dir(response.body)
         })
         it('should return an object with an id', async () => {
           assert.strictEqual(typeof response.body.id, 'string')

package/tests/routes.inbox.test.js

@@ -68,6 +68,7 @@ describe('routes.inbox', async () => {
       )
     })
   })
+
   describe('can handle a duplicate incoming activity', async () => {
     const username = 'actor2'
     const botName = 'test1'

package/tests/routes.object.test.js

@@ -10,7 +10,9 @@ const uppercase = (string) => string.charAt(0).toUpperCase() + string.slice(1)
 
 describe('object collection routes', async () => {
   const databaseUrl = 'sqlite::memory:'
-  const origin = 'https://activitypubbot.test'
+  const host = 'activitypubbot.test'
+  const origin = `https://${host}`
+  const remote = 'social.example'
   const username = 'ok'
   const type = 'object'
   const nanoid = 'hUQC9HWian7dzOxZJlJBA'
@@ -25,7 +27,7 @@ describe('object collection routes', async () => {
   before(async () => {
     app = await makeApp(databaseUrl, origin, bots, 'silent')
     const { formatter, objectStorage, actorStorage } = app.locals
-    nockSetup('social.example')
+    nockSetup(remote)
     obj = await as2.import({
       id: formatter.format({ username, type, nanoid }),
       type: uppercase(type),
@@ -42,14 +44,14 @@ describe('object collection routes', async () => {
     await objectStorage.addToCollection(obj.id, 'thread', obj)
     reply = await as2.import({
       id: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'replier1',
         type: 'note',
         num: 1
       }),
       type: 'Note',
       attributedTo: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'replier1'
       }),
       content: 'This is a reply to the test object',
@@ -60,7 +62,7 @@ describe('object collection routes', async () => {
     await objectStorage.addToCollection(obj.id, 'thread', reply)
     like = await as2.import({
       id: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'liker1',
         type: 'like',
         num: 1,
@@ -68,7 +70,7 @@ describe('object collection routes', async () => {
       }),
       type: 'Like',
       attributedTo: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'liker1'
       }),
       object: obj.id,
@@ -77,7 +79,7 @@ describe('object collection routes', async () => {
     await objectStorage.addToCollection(obj.id, 'likes', like)
     share = await as2.import({
       id: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'sharer1',
         type: 'announce',
         num: 1,
@@ -85,7 +87,7 @@ describe('object collection routes', async () => {
       }),
       type: 'Announce',
       attributedTo: nockFormat({
-        domain: 'social.example',
+        domain: remote,
         username: 'sharer1'
       }),
       object: obj.id,
@@ -105,10 +107,14 @@ describe('object collection routes', async () => {
       to: formatter.format({ username, collection: 'followers' })
     })
     await objectStorage.create(privateObj)
+    const follower = await makeActor('follower1', remote)
     await actorStorage.addToCollection(
       username,
       'followers',
-      await makeActor('follower1', 'social.example')
+      follower
+    )
+    assert.ok(
+      await actorStorage.isInCollection(username, 'followers', follower)
     )
   })
 
@@ -130,7 +136,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -142,15 +148,15 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right replies', async () => {
       assert.strictEqual(typeof response.body.replies, 'string')
-      assert.strictEqual(response.body.replies, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies`)
+      assert.strictEqual(response.body.replies, `${origin}/user/${username}/${type}/${nanoid}/replies`)
     })
     it('should return an object with the right likes', async () => {
       assert.strictEqual(typeof response.body.likes, 'string')
-      assert.strictEqual(response.body.likes, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes`)
+      assert.strictEqual(response.body.likes, `${origin}/user/${username}/${type}/${nanoid}/likes`)
     })
     it('should return an object with the right shares', async () => {
       assert.strictEqual(typeof response.body.shares, 'string')
-      assert.strictEqual(response.body.shares, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares`)
+      assert.strictEqual(response.body.shares, `${origin}/user/${username}/${type}/${nanoid}/shares`)
     })
   })
 
@@ -172,7 +178,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/replies`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -184,11 +190,11 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right first', async () => {
       assert.strictEqual(typeof response.body.first, 'string')
-      assert.strictEqual(response.body.first, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies/1`)
+      assert.strictEqual(response.body.first, `${origin}/user/${username}/${type}/${nanoid}/replies/1`)
     })
     it('should return an object with the right last', async () => {
       assert.strictEqual(typeof response.body.last, 'string')
-      assert.strictEqual(response.body.last, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies/1`)
+      assert.strictEqual(response.body.last, `${origin}/user/${username}/${type}/${nanoid}/replies/1`)
     })
     it('should return an object with the right repliesOf', async () => {
       assert.strictEqual(typeof response.body.repliesOf, 'string')
@@ -214,7 +220,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies/1`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/replies/1`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -222,7 +228,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right partOf', async () => {
       assert.strictEqual(typeof response.body.partOf, 'string')
-      assert.strictEqual(response.body.partOf, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/replies`)
+      assert.strictEqual(response.body.partOf, `${origin}/user/${username}/${type}/${nanoid}/replies`)
     })
     it('should return an object with the right items', async () => {
       assert.strictEqual(typeof response.body.items, 'object')
@@ -249,7 +255,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/likes`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -261,11 +267,11 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right first', async () => {
       assert.strictEqual(typeof response.body.first, 'string')
-      assert.strictEqual(response.body.first, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes/1`)
+      assert.strictEqual(response.body.first, `${origin}/user/${username}/${type}/${nanoid}/likes/1`)
     })
     it('should return an object with the right last', async () => {
       assert.strictEqual(typeof response.body.last, 'string')
-      assert.strictEqual(response.body.last, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes/1`)
+      assert.strictEqual(response.body.last, `${origin}/user/${username}/${type}/${nanoid}/likes/1`)
     })
     it('should return an object with the right likesOf', async () => {
       assert.strictEqual(typeof response.body.likesOf, 'string')
@@ -291,7 +297,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes/1`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/likes/1`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -299,7 +305,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right partOf', async () => {
       assert.strictEqual(typeof response.body.partOf, 'string')
-      assert.strictEqual(response.body.partOf, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/likes`)
+      assert.strictEqual(response.body.partOf, `${origin}/user/${username}/${type}/${nanoid}/likes`)
     })
     it('should return an object with the right items', async () => {
       assert.strictEqual(typeof response.body.items, 'object')
@@ -326,7 +332,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/shares`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -338,11 +344,11 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right first', async () => {
       assert.strictEqual(typeof response.body.first, 'string')
-      assert.strictEqual(response.body.first, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares/1`)
+      assert.strictEqual(response.body.first, `${origin}/user/${username}/${type}/${nanoid}/shares/1`)
     })
     it('should return an object with the right last', async () => {
       assert.strictEqual(typeof response.body.last, 'string')
-      assert.strictEqual(response.body.last, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares/1`)
+      assert.strictEqual(response.body.last, `${origin}/user/${username}/${type}/${nanoid}/shares/1`)
     })
     it('should return an object with the right sharesOf', async () => {
       assert.strictEqual(typeof response.body.sharesOf, 'string')
@@ -368,7 +374,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares/1`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/shares/1`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -376,7 +382,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right partOf', async () => {
       assert.strictEqual(typeof response.body.partOf, 'string')
-      assert.strictEqual(response.body.partOf, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/shares`)
+      assert.strictEqual(response.body.partOf, `${origin}/user/${username}/${type}/${nanoid}/shares`)
     })
     it('should return an object with the right items', async () => {
       assert.strictEqual(typeof response.body.items, 'object')
@@ -423,16 +429,16 @@ describe('object collection routes', async () => {
 
   describe('Get private object with follower', async () => {
     let response = null
-    const path = `/user/${username}/${type}/${privateNanoid}`
-    const url = `${origin}${path}`
-    const date = new Date().toISOString()
-    const signature = await nockSignature({ username: 'follower1', url, date })
     it('should work without an error', async () => {
+      const path = `/user/${username}/${type}/${privateNanoid}`
+      const url = `${origin}${path}`
+      const date = new Date().toISOString()
+      const signature = await nockSignature({ username: 'follower1', url, date })
       response = await request(app)
         .get(path)
         .set('Signature', signature)
         .set('Date', date)
-        .set('Host', 'activitypubbot.test')
+        .set('Host', host)
     })
     it('should return a 200 status', async () => {
       assert.strictEqual(response.status, 200)
@@ -457,7 +463,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/thread`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/thread`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -469,11 +475,11 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right first', async () => {
       assert.strictEqual(typeof response.body.first, 'string')
-      assert.strictEqual(response.body.first, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/thread/1`)
+      assert.strictEqual(response.body.first, `${origin}/user/${username}/${type}/${nanoid}/thread/1`)
     })
     it('should return an object with the right last', async () => {
       assert.strictEqual(typeof response.body.last, 'string')
-      assert.strictEqual(response.body.last, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/thread/1`)
+      assert.strictEqual(response.body.last, `${origin}/user/${username}/${type}/${nanoid}/thread/1`)
     })
     it('should return an object with the right root', async () => {
       assert.strictEqual(typeof response.body.root, 'string')
@@ -499,7 +505,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object the right id', async () => {
       assert.strictEqual(typeof response.body.id, 'string')
-      assert.strictEqual(response.body.id, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/thread/1`)
+      assert.strictEqual(response.body.id, `${origin}/user/${username}/${type}/${nanoid}/thread/1`)
     })
     it('should return an object with the right type', async () => {
       assert.strictEqual(typeof response.body.type, 'string')
@@ -507,7 +513,7 @@ describe('object collection routes', async () => {
     })
     it('should return an object with the right partOf', async () => {
       assert.strictEqual(typeof response.body.partOf, 'string')
-      assert.strictEqual(response.body.partOf, `https://activitypubbot.test/user/${username}/${type}/${nanoid}/thread`)
+      assert.strictEqual(response.body.partOf, `${origin}/user/${username}/${type}/${nanoid}/thread`)
     })
     it('should return an object with the right items', async () => {
       assert.strictEqual(typeof response.body.items, 'object')