@evanp/activitypub-bot 0.8.0

package/tests/routes.collection.test.js

@@ -0,0 +1,434 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { makeApp } from '../lib/app.js'
+import request from 'supertest'
+import bots from './fixtures/bots.js'
+import as2 from '../lib/activitystreams.js'
+import { nanoid } from 'nanoid'
+
+describe('actor collection routes', async () => {
+  const databaseUrl = 'sqlite::memory:'
+  const origin = 'https://activitypubbot.test'
+  const app = await makeApp(databaseUrl, origin, bots, 'silent')
+
+  for (const coll of ['outbox', 'liked', 'followers', 'following']) {
+    describe(`${coll} collection`, async () => {
+      describe(`GET /user/{botid}/${coll}`, async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get(`/user/ok/${coll}`)
+        })
+        it('should return 200 OK', async () => {
+          assert.strictEqual(response.status, 200)
+        })
+        it('should return AS2', async () => {
+          assert.strictEqual(response.type, 'application/activity+json')
+        })
+        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')
+        })
+        it('should return an object with an id matching the request', async () => {
+          assert.strictEqual(response.body.id, origin + `/user/ok/${coll}`)
+        })
+        it('should return an object with a type', async () => {
+          assert.strictEqual(typeof response.body.type, 'string')
+        })
+        it('should return an object with a type matching the request', async () => {
+          assert.strictEqual(response.body.type, 'OrderedCollection')
+        })
+        it('should return an object with a totalItems', async () => {
+          assert.strictEqual(typeof response.body.totalItems, 'number')
+        })
+        it('should return an object with attributedTo', async () => {
+          assert.strictEqual(typeof response.body.attributedTo, 'string')
+        })
+        it('should return an object with attributedTo matching the bot', async () => {
+          assert.strictEqual(response.body.attributedTo, origin + '/user/ok')
+        })
+        it('should return an object with a to', async () => {
+          assert.strictEqual(typeof response.body.to, 'string')
+        })
+        it('should return an object with a to for the public', async () => {
+          assert.strictEqual(response.body.to, 'as:Public')
+        })
+        it('should return an object with a summary', async () => {
+          assert.strictEqual(typeof response.body.summaryMap, 'object')
+          assert.strictEqual(typeof response.body.summaryMap.en, 'string')
+        })
+        it('should return an object with a first', async () => {
+          assert.strictEqual(typeof response.body.first, 'string')
+        })
+        it('should return an object with a last', async () => {
+          assert.strictEqual(typeof response.body.last, 'string')
+        })
+        it(`should return an object with a ${coll}Of to the actor`, async () => {
+          assert.strictEqual(typeof response.body[coll + 'Of'], 'string')
+          assert.strictEqual(response.body[coll + 'Of'], origin + '/user/ok')
+        })
+      })
+      describe('GET collection for non-existent user', async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get('/user/dne/' + coll)
+        })
+        it('should return 404 Not Found', async () => {
+          assert.strictEqual(response.status, 404)
+        })
+        it('should return Problem Details JSON', async () => {
+          assert.strictEqual(response.type, 'application/problem+json')
+        })
+        it('should return an object', async () => {
+          assert.strictEqual(typeof response.body, 'object')
+        })
+        it('should return an object with a type', async () => {
+          assert.strictEqual(typeof response.body.type, 'string')
+        })
+        it('should return an object with an type matching the request', async () => {
+          assert.strictEqual(response.body.type, 'about:blank')
+        })
+        it('should return an object with a title', async () => {
+          assert.strictEqual(typeof response.body.title, 'string')
+        })
+        it('should return an object with a title matching the request', async () => {
+          assert.strictEqual(response.body.title, 'Not Found')
+        })
+        it('should return an object with a status', async () => {
+          assert.strictEqual(typeof response.body.status, 'number')
+        })
+        it('should return an object with a status matching the request', async () => {
+          assert.strictEqual(response.body.status, 404)
+        })
+        it('should return an object with a detail', async () => {
+          assert.strictEqual(typeof response.body.detail, 'string')
+        })
+        it('should return an object with a detail matching the request', async () => {
+          assert.strictEqual(response.body.detail, 'User dne not found')
+        })
+      })
+      describe(`GET /user/{botid}/${coll}/1`, async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get(`/user/ok/${coll}/1`)
+        })
+        it('should return 200 OK', async () => {
+          assert.strictEqual(response.status, 200)
+        })
+        it('should return AS2', async () => {
+          assert.strictEqual(response.type, 'application/activity+json')
+        })
+        it('should return an object', async () => {
+          assert.strictEqual(typeof response.body, 'object')
+        })
+        it('should return an object with an id', async () => {
+          assert.strictEqual(typeof response.body.id, 'string')
+        })
+        it('should return an object with an id matching the request', async () => {
+          assert.strictEqual(response.body.id, origin + `/user/ok/${coll}/1`)
+        })
+        it('should return an object with a type', async () => {
+          assert.strictEqual(typeof response.body.type, 'string')
+        })
+        it('should return an object with a type matching the request', async () => {
+          assert.strictEqual(response.body.type, 'OrderedCollectionPage')
+        })
+        it('should return an object with attributedTo', async () => {
+          assert.strictEqual(typeof response.body.attributedTo, 'string')
+        })
+        it('should return an object with attributedTo matching the bot', async () => {
+          assert.strictEqual(response.body.attributedTo, origin + '/user/ok')
+        })
+        it('should return an object with a to', async () => {
+          assert.strictEqual(typeof response.body.to, 'string')
+        })
+        it('should return an object with a to for the public', async () => {
+          assert.strictEqual(response.body.to, 'as:Public')
+        })
+        it('should return an object with a summary', async () => {
+          assert.strictEqual(typeof response.body.summaryMap, 'object')
+          assert.strictEqual(typeof response.body.summaryMap.en, 'string')
+        })
+        it('should return an object with a partOf', async () => {
+          assert.strictEqual(typeof response.body.partOf, 'string')
+        })
+        it('should return an object with a partOf matching the collection', async () => {
+          assert.strictEqual(response.body.partOf, origin + `/user/ok/${coll}`)
+        })
+      })
+      describe('GET collection page for non-existent user', async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get('/user/dne/' + coll + '/1')
+        })
+        it('should return 404 Not Found', async () => {
+          assert.strictEqual(response.status, 404)
+        })
+        it('should return Problem Details JSON', async () => {
+          assert.strictEqual(response.type, 'application/problem+json')
+        })
+        it('should return an object', async () => {
+          assert.strictEqual(typeof response.body, 'object')
+        })
+        it('should return an object with a type', async () => {
+          assert.strictEqual(typeof response.body.type, 'string')
+        })
+        it('should return an object with an type matching the request', async () => {
+          assert.strictEqual(response.body.type, 'about:blank')
+        })
+        it('should return an object with a title', async () => {
+          assert.strictEqual(typeof response.body.title, 'string')
+        })
+        it('should return an object with a title matching the request', async () => {
+          assert.strictEqual(response.body.title, 'Not Found')
+        })
+        it('should return an object with a status', async () => {
+          assert.strictEqual(typeof response.body.status, 'number')
+        })
+        it('should return an object with a status matching the request', async () => {
+          assert.strictEqual(response.body.status, 404)
+        })
+        it('should return an object with a detail', async () => {
+          assert.strictEqual(typeof response.body.detail, 'string')
+        })
+        it('should return an object with a detail matching the request', async () => {
+          assert.strictEqual(response.body.detail, 'User dne not found')
+        })
+      })
+      describe('GET non-existent page for existent collection and existent user', async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get('/user/ok/' + coll + '/99999999')
+        })
+        it('should return 404 Not Found', async () => {
+          assert.strictEqual(response.status, 404)
+        })
+        it('should return Problem Details JSON', async () => {
+          assert.strictEqual(response.type, 'application/problem+json')
+        })
+        it('should return an object', async () => {
+          assert.strictEqual(typeof response.body, 'object')
+        })
+        it('should return an object with a type', async () => {
+          assert.strictEqual(typeof response.body.type, 'string')
+        })
+        it('should return an object with an type matching the request', async () => {
+          assert.strictEqual(response.body.type, 'about:blank')
+        })
+        it('should return an object with a title', async () => {
+          assert.strictEqual(typeof response.body.title, 'string')
+        })
+        it('should return an object with a title matching the request', async () => {
+          assert.strictEqual(response.body.title, 'Not Found')
+        })
+        it('should return an object with a status', async () => {
+          assert.strictEqual(typeof response.body.status, 'number')
+        })
+        it('should return an object with a status matching the request', async () => {
+          assert.strictEqual(response.body.status, 404)
+        })
+        it('should return an object with a detail', async () => {
+          assert.strictEqual(typeof response.body.detail, 'string')
+        })
+        it('should return an object with a detail matching the request', async () => {
+          assert.strictEqual(response.body.detail, 'No such page 99999999 for collection ' + coll + ' for user ok')
+        })
+      })
+    })
+  }
+
+  describe('GET non-existent collection for existent user', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/ok/dne')
+    })
+    it('should return 404 Not Found', async () => {
+      assert.strictEqual(response.status, 404)
+    })
+    it('should return Problem Details JSON', async () => {
+      assert.strictEqual(response.type, 'application/problem+json')
+    })
+    it('should return an object', async () => {
+      assert.strictEqual(typeof response.body, 'object')
+    })
+    it('should return an object with a type', async () => {
+      assert.strictEqual(typeof response.body.type, 'string')
+    })
+    it('should return an object with an type matching the request', async () => {
+      assert.strictEqual(response.body.type, 'about:blank')
+    })
+    it('should return an object with a title', async () => {
+      assert.strictEqual(typeof response.body.title, 'string')
+    })
+    it('should return an object with a title matching the request', async () => {
+      assert.strictEqual(response.body.title, 'Not Found')
+    })
+    it('should return an object with a status', async () => {
+      assert.strictEqual(typeof response.body.status, 'number')
+    })
+    it('should return an object with a status matching the request', async () => {
+      assert.strictEqual(response.body.status, 404)
+    })
+    it('should return an object with a detail', async () => {
+      assert.strictEqual(typeof response.body.detail, 'string')
+    })
+    it('should return an object with a detail matching the request', async () => {
+      assert.strictEqual(response.body.detail, 'No such collection dne for user ok')
+    })
+  })
+
+  describe('GET page for non-existent collection for existent user', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/ok/dne/1')
+    })
+    it('should return 404 Not Found', async () => {
+      assert.strictEqual(response.status, 404)
+    })
+    it('should return Problem Details JSON', async () => {
+      assert.strictEqual(response.type, 'application/problem+json')
+    })
+    it('should return an object', async () => {
+      assert.strictEqual(typeof response.body, 'object')
+    })
+    it('should return an object with a type', async () => {
+      assert.strictEqual(typeof response.body.type, 'string')
+    })
+    it('should return an object with an type matching the request', async () => {
+      assert.strictEqual(response.body.type, 'about:blank')
+    })
+    it('should return an object with a title', async () => {
+      assert.strictEqual(typeof response.body.title, 'string')
+    })
+    it('should return an object with a title matching the request', async () => {
+      assert.strictEqual(response.body.title, 'Not Found')
+    })
+    it('should return an object with a status', async () => {
+      assert.strictEqual(typeof response.body.status, 'number')
+    })
+    it('should return an object with a status matching the request', async () => {
+      assert.strictEqual(response.body.status, 404)
+    })
+    it('should return an object with a detail', async () => {
+      assert.strictEqual(typeof response.body.detail, 'string')
+    })
+    it('should return an object with a detail matching the request', async () => {
+      assert.strictEqual(response.body.detail, 'No such collection dne for user ok')
+    })
+  })
+
+  describe('GET /user/{botid}/inbox', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/ok/inbox')
+    })
+    it('should return 403 Forbidden', async () => {
+      assert.strictEqual(response.status, 403)
+    })
+    it('should return Problem Details JSON', async () => {
+      assert.strictEqual(response.type, 'application/problem+json')
+    })
+    it('should return an object', async () => {
+      assert.strictEqual(typeof response.body, 'object')
+    })
+    it('should return an object with a type', async () => {
+      assert.strictEqual(typeof response.body.type, 'string')
+    })
+    it('should return an object with an type matching the request', async () => {
+      assert.strictEqual(response.body.type, 'about:blank')
+    })
+    it('should return an object with a title', async () => {
+      assert.strictEqual(typeof response.body.title, 'string')
+    })
+    it('should return an object with a title matching the request', async () => {
+      assert.strictEqual(response.body.title, 'Forbidden')
+    })
+    it('should return an object with a status', async () => {
+      assert.strictEqual(typeof response.body.status, 'number')
+    })
+    it('should return an object with a status matching the request', async () => {
+      assert.strictEqual(response.body.status, 403)
+    })
+    it('should return an object with a detail', async () => {
+      assert.strictEqual(typeof response.body.detail, 'string')
+    })
+    it('should return an object with a detail matching the request', async () => {
+      assert.strictEqual(response.body.detail, 'No access to inbox collection')
+    })
+  })
+
+  describe('GET /user/{botid}/inbox/1', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/ok/inbox/1')
+    })
+    it('should return 403 Forbidden', async () => {
+      assert.strictEqual(response.status, 403)
+    })
+    it('should return Problem Details JSON', async () => {
+      assert.strictEqual(response.type, 'application/problem+json')
+    })
+    it('should return an object', async () => {
+      assert.strictEqual(typeof response.body, 'object')
+    })
+    it('should return an object with a type', async () => {
+      assert.strictEqual(typeof response.body.type, 'string')
+    })
+    it('should return an object with an type matching the request', async () => {
+      assert.strictEqual(response.body.type, 'about:blank')
+    })
+    it('should return an object with a title', async () => {
+      assert.strictEqual(typeof response.body.title, 'string')
+    })
+    it('should return an object with a title matching the request', async () => {
+      assert.strictEqual(response.body.title, 'Forbidden')
+    })
+    it('should return an object with a status', async () => {
+      assert.strictEqual(typeof response.body.status, 'number')
+    })
+    it('should return an object with a status matching the request', async () => {
+      assert.strictEqual(response.body.status, 403)
+    })
+    it('should return an object with a detail', async () => {
+      assert.strictEqual(typeof response.body.detail, 'string')
+    })
+    it('should return an object with a detail matching the request', async () => {
+      assert.strictEqual(response.body.detail, 'No access to inbox collection')
+    })
+  })
+
+  describe('GET /user/{botid}/outbox/1 with contents', async () => {
+    let response = null
+    const username = 'test0'
+    const actorStorage = app.locals.actorStorage
+    const objectStorage = app.locals.objectStorage
+    const formatter = app.locals.formatter
+
+    for (let i = 0; i < 20; i++) {
+      const activity = await as2.import({
+        '@context': 'https://www.w3.org/ns/activitystreams',
+        to: 'as:Public',
+        actor: formatter.format({ username }),
+        type: 'IntransitiveActivity',
+        id: formatter.format({
+          username,
+          type: 'intransitiveactivity',
+          nanoid: nanoid()
+        }),
+        summary: 'An intransitive activity by the test0 bot',
+        published: (new Date()).toISOString()
+      })
+      await objectStorage.create(activity)
+      await actorStorage.addToCollection(username, 'outbox', activity)
+    }
+
+    it('should work without an error', async () => {
+      response = await request(app).get(`/user/${username}/outbox/1`)
+    })
+    it('should return 200 OK', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+  })
+})

package/tests/routes.health.test.js

@@ -0,0 +1,41 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { makeApp } from '../lib/app.js'
+import request from 'supertest'
+import bots from './fixtures/bots.js'
+
+describe('health check routes', async () => {
+  const databaseUrl = 'sqlite::memory:'
+  const origin = 'https://activitypubbot.test'
+  const app = await makeApp(databaseUrl, origin, bots, 'silent')
+  describe('GET /livez', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/livez')
+    })
+    it('should return 200 OK', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+    it('should return plain text', async () => {
+      assert.strictEqual(response.type, 'text/plain')
+    })
+    it('should return an OK flag', async () => {
+      assert.strictEqual(response.text, 'OK')
+    })
+  })
+  describe('GET /readyz', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/readyz')
+    })
+    it('should return 200 OK', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+    it('should return plain text', async () => {
+      assert.strictEqual(response.type, 'text/plain')
+    })
+    it('should return an OK flag', async () => {
+      assert.strictEqual(response.text, 'OK')
+    })
+  })
+})

package/tests/routes.inbox.test.js

@@ -0,0 +1,135 @@
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert'
+import as2 from '../lib/activitystreams.js'
+import request from 'supertest'
+
+import { makeApp } from '../lib/app.js'
+
+import { nockSetup, nockSignature, nockFormat } from './utils/nock.js'
+import { makeDigest } from './utils/digest.js'
+import bots from './fixtures/bots.js'
+
+describe('routes.inbox', async () => {
+  const host = 'activitypubbot.test'
+  const origin = `https://${host}`
+  const databaseUrl = 'sqlite::memory:'
+  let app = null
+
+  before(async () => {
+    nockSetup('social.example')
+    app = await makeApp(databaseUrl, origin, bots, 'silent')
+  })
+
+  describe('can handle an incoming activity', async () => {
+    const username = 'actor1'
+    const botName = 'test0'
+    const path = `/user/${botName}/inbox`
+    const url = `${origin}${path}`
+    const date = new Date().toUTCString()
+    const activity = await as2.import({
+      type: 'Activity',
+      actor: nockFormat({ username }),
+      id: nockFormat({ username, type: 'activity', num: 1 })
+    })
+    const body = await activity.write()
+    const digest = makeDigest(body)
+    const signature = await nockSignature({
+      method: 'POST',
+      username,
+      url,
+      digest,
+      date
+    })
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app)
+        .post(path)
+        .send(body)
+        .set('Signature', signature)
+        .set('Date', date)
+        .set('Host', host)
+        .set('Digest', digest)
+        .set('Content-Type', 'application/activity+json')
+      assert.ok(response)
+      await app.onIdle()
+    })
+    it('should return a 200 status', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+    it('should appear in the inbox', async () => {
+      const { actorStorage } = app.locals
+      assert.strictEqual(
+        true,
+        await actorStorage.isInCollection(
+          botName,
+          'inbox',
+          activity
+        )
+      )
+    })
+  })
+  describe('can handle a duplicate incoming activity', async () => {
+    const username = 'actor2'
+    const botName = 'test1'
+    const path = `/user/${botName}/inbox`
+    const url = `${origin}${path}`
+    const date = new Date().toUTCString()
+    const activity = await as2.import({
+      type: 'Activity',
+      actor: nockFormat({ username }),
+      id: nockFormat({ username, type: 'activity', num: 2 }),
+      to: 'as:Public'
+    })
+    const body = await activity.write()
+    const digest = makeDigest(body)
+    const signature = await nockSignature({
+      method: 'POST',
+      username,
+      url,
+      digest,
+      date
+    })
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app)
+        .post(path)
+        .send(body)
+        .set('Signature', signature)
+        .set('Date', date)
+        .set('Host', host)
+        .set('Digest', digest)
+        .set('Content-Type', 'application/activity+json')
+      assert.ok(response)
+      await app.onIdle()
+    })
+    it('should return a 200 status', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+    it('should appear in the inbox', async () => {
+      const { actorStorage } = app.locals
+      assert.strictEqual(
+        true,
+        await actorStorage.isInCollection(
+          botName,
+          'inbox',
+          activity
+        )
+      )
+    })
+    it('should fail the second time', async () => {
+      response = await request(app)
+        .post(path)
+        .send(body)
+        .set('Signature', signature)
+        .set('Date', date)
+        .set('Host', host)
+        .set('Digest', digest)
+        .set('Content-Type', 'application/activity+json')
+      assert.ok(response)
+      await app.onIdle()
+    })
+    it('should return a 400 status', async () => {
+      assert.strictEqual(response.status, 400)
+    })
+  })
+})