@evanp/activitypub-bot 0.9.0 → 0.12.0

package/tests/botfactory.provincebotfactory.test.js

@@ -0,0 +1,430 @@
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert'
+import request from 'supertest'
+import as2 from '../lib/activitystreams.js'
+
+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('ProvinceBotFactory', async () => {
+  const host = 'activitypubbot.example'
+  const origin = `https://${host}`
+  const databaseUrl = 'sqlite::memory:'
+  let app = null
+
+  before(async () => {
+    nockSetup('social.example')
+    app = await makeApp(databaseUrl, origin, bots, 'silent')
+  })
+
+  describe('Webfinger discovery for province', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/.well-known/webfinger?resource=acct%3Aqc%40activitypubbot.example')
+    })
+    it('should return 200 OK', async () => {
+      assert.strictEqual(response.status, 200)
+    })
+    it('should return JRD', async () => {
+      assert.strictEqual(response.type, 'application/jrd+json')
+    })
+    it('should return an object with a subject', async () => {
+      assert.strictEqual(typeof response.body.subject, 'string')
+    })
+    it('should return an object with an subject matching the request', async () => {
+      assert.strictEqual(response.body.subject, 'acct:qc@activitypubbot.example')
+    })
+    it('should return an object with a links array', async () => {
+      assert.strictEqual(Array.isArray(response.body.links), true)
+    })
+    it('should return an object with a links array containing the actor id', async () => {
+      assert.strictEqual(response.body.links.length, 1)
+      assert.strictEqual(typeof response.body.links[0].rel, 'string')
+      assert.strictEqual(response.body.links[0].rel, 'self')
+      assert.strictEqual(typeof response.body.links[0].type, 'string')
+      assert.strictEqual(response.body.links[0].type, 'application/activity+json')
+      assert.strictEqual(typeof response.body.links[0].href, 'string')
+      assert.strictEqual(response.body.links[0].href, 'https://activitypubbot.example/user/qc')
+    })
+  })
+
+  describe('Actor for province', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/qc')
+    })
+    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/qc')
+    })
+    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, 'Service')
+    })
+    it('should return an object with a preferredUsername', async () => {
+      assert.strictEqual(typeof response.body.preferredUsername, 'string')
+    })
+    it('should return an object with a preferredUsername matching the request', async () => {
+      assert.strictEqual(response.body.preferredUsername, 'qc')
+    })
+    it('should return an object with an inbox', async () => {
+      assert.strictEqual(typeof response.body.inbox, 'string')
+    })
+    it('should return an object with an outbox', async () => {
+      assert.strictEqual(typeof response.body.outbox, 'string')
+    })
+    it('should return an object with a followers', async () => {
+      assert.strictEqual(typeof response.body.followers, 'string')
+    })
+    it('should return an object with a following', async () => {
+      assert.strictEqual(typeof response.body.following, 'string')
+    })
+    it('should return an object with a liked', async () => {
+      assert.strictEqual(typeof response.body.liked, 'string')
+    })
+    it('should return an object with a to', async () => {
+      assert.strictEqual(typeof response.body.to, 'string')
+    })
+    it('should return an object with a to matching the request', async () => {
+      assert.strictEqual(response.body.to, 'as:Public')
+    })
+    it('should return an object with a summary', async () => {
+      assert.strictEqual(typeof response.body.summary, 'string')
+    })
+    it('should return an object with a summary matching the request', async () => {
+      assert.strictEqual(response.body.summary, 'The province of Quebec')
+    })
+    it('should return an object with a name', async () => {
+      assert.strictEqual(typeof response.body.name, 'string')
+    })
+    it('should return an object with a name matching the request', async () => {
+      assert.strictEqual(response.body.name, 'Quebec')
+    })
+    it('should return an object with a publicKey', async () => {
+      assert.strictEqual(typeof response.body.publicKey, 'object')
+      assert.ok(response.body.publicKey)
+    })
+    it('should return an object with a publicKey matching the request', async () => {
+      assert.strictEqual(response.body.publicKey.id, origin + '/user/qc/publickey')
+    })
+    it('should return an object with a publicKey with an owner matching the request', async () => {
+      assert.strictEqual(response.body.publicKey.owner, origin + '/user/qc')
+    })
+    it('should return an object with a publicKey with a type', async () => {
+      assert.strictEqual(response.body.publicKey.type, 'CryptographicKey')
+    })
+    it('should return an object with a publicKey with a to', async () => {
+      assert.strictEqual(response.body.publicKey.to, 'as:Public')
+    })
+    it('should return an object with a publicKey with a publicKeyPem', async () => {
+      assert.strictEqual(typeof response.body.publicKey.publicKeyPem, 'string')
+    })
+    it('publicKeyPem should be an RSA PKCS-8 key', async () => {
+      assert.match(response.body.publicKey.publicKeyPem, /^-----BEGIN PUBLIC KEY-----\n/)
+      assert.match(response.body.publicKey.publicKeyPem, /\n-----END PUBLIC KEY-----\n$/)
+    })
+  })
+
+  describe('Public key for province', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/qc/publickey')
+    })
+    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 the requested public key id', async () => {
+      assert.strictEqual(response.body.id, origin + '/user/qc/publickey')
+    })
+    it('should return an object with an owner', async () => {
+      assert.strictEqual(typeof response.body.owner, 'string')
+    })
+    it('should return an object with the bot as owner', async () => {
+      assert.strictEqual(response.body.owner, origin + '/user/qc')
+    })
+    it('should return an object with a publicKeyPem', async () => {
+      assert.strictEqual(typeof response.body.publicKeyPem, 'string')
+    })
+    it('publicKeyPem should be an RSA PKCS-8 key', async () => {
+      assert.match(response.body.publicKeyPem, /^-----BEGIN PUBLIC KEY-----\n/)
+      assert.match(response.body.publicKeyPem, /\n-----END PUBLIC KEY-----\n$/)
+    })
+    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, 'CryptographicKey')
+    })
+    it('should return an object with a to', async () => {
+      assert.strictEqual(typeof response.body.to, 'string')
+    })
+    it('should return an object with a to matching the request', async () => {
+      assert.strictEqual(response.body.to, 'as:Public')
+    })
+  })
+
+  for (const coll of ['outbox', 'liked', 'followers', 'following']) {
+    describe(`Province ${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/qc/${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')
+        })
+        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/qc/${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/qc')
+        })
+        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/qc')
+        })
+      })
+      describe(`GET /user/{botid}/${coll}/1`, async () => {
+        let response = null
+        it('should work without an error', async () => {
+          response = await request(app).get(`/user/qc/${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/qc/${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/qc')
+        })
+        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/qc/${coll}`)
+        })
+      })
+    })
+  }
+
+  describe('Province inbox collection', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/qc/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('Province inbox page', async () => {
+    let response = null
+    it('should work without an error', async () => {
+      response = await request(app).get('/user/qc/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('Province inbox incoming activity', async () => {
+    const username = 'actor1'
+    const botName = 'qc'
+    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
+        )
+      )
+    })
+  })
+})

package/tests/fixtures/bots.js

@@ -1,5 +1,7 @@
 import DoNothingBot from '../../lib/bots/donothing.js'
 import OKBot from '../../lib/bots/ok.js'
+import EventLoggingBot from './eventloggingbot.js'
+import ProvinceBotFactory from './provincebotfactory.js'
 
 export default {
   ok: new OKBot('ok'),
@@ -11,5 +13,15 @@ export default {
   test4: new DoNothingBot('test4'),
   test5: new DoNothingBot('test5'),
   test6: new DoNothingBot('test6'),
-  test7: new DoNothingBot('test7')
+  test7: new DoNothingBot('test7'),
+  test8: new DoNothingBot('test8'),
+  test9: new DoNothingBot('test9'),
+  test10: new DoNothingBot('test10'),
+  test11: new DoNothingBot('test11'),
+  test12: new DoNothingBot('test12'),
+  test13: new DoNothingBot('test13'),
+  test14: new DoNothingBot('test14'),
+  test15: new DoNothingBot('test15'),
+  logging: new EventLoggingBot('logging'),
+  '*': new ProvinceBotFactory()
 }

package/tests/fixtures/eventloggingbot.js

@@ -0,0 +1,57 @@
+import Bot from '../../lib/bot.js'
+
+export default class EventLoggingBot extends Bot {
+  #follows = new Map()
+  #mentions = new Map()
+  #likes = new Map()
+  #publics = new Map()
+  #shares = new Map()
+
+  get fullname () {
+    return 'Event-logging bot'
+  }
+
+  get description () {
+    return 'A bot that logs events that happen to it'
+  }
+
+  async onMention (object, activity) {
+    this.#mentions.set(activity.id, activity)
+  }
+
+  async onFollow (actor, activity) {
+    this.#follows.set(activity.id, activity)
+  }
+
+  async onLike (object, activity) {
+    this.#likes.set(activity.id, activity)
+  }
+
+  async onPublic (activity) {
+    this.#publics.set(activity.id, activity)
+  }
+
+  async onAnnounce (object, activity) {
+    this.#shares.set(activity.id, activity)
+  }
+
+  get follows () {
+    return this.#follows
+  }
+
+  get mentions () {
+    return this.#mentions
+  }
+
+  get likes () {
+    return this.#likes
+  }
+
+  get publics () {
+    return this.#publics
+  }
+
+  get shares () {
+    return this.#shares
+  }
+}

package/tests/fixtures/provincebotfactory.js

@@ -0,0 +1,53 @@
+import BotFactory from '../../lib/botfactory.js'
+import Bot from '../../lib/bot.js'
+
+class ProvinceBot extends Bot {
+  #name
+  #type
+
+  constructor (username, name, type) {
+    super(username)
+    this.#name = name
+    this.#type = type
+  }
+
+  get fullname () {
+    return this.#name
+  }
+
+  get description () {
+    return `The ${this.#type} of ${this.#name}`
+  }
+}
+
+export default class ProvinceBotFactory extends BotFactory {
+  static #provinces = {
+    ab: ['Alberta', 'province'],
+    on: ['Ontario', 'province'],
+    qc: ['Quebec', 'province'],
+    bc: ['British Columbia', 'province'],
+    mb: ['Manitoba', 'province'],
+    sk: ['Saskatchewan', 'province'],
+    nb: ['New Brunswick', 'province'],
+    ns: ['Nova Scotia', 'province'],
+    pe: ['Prince Edward Island', 'province'],
+    nl: ['Newfoundland and Labrador', 'province'],
+    nu: ['Nunavut', 'territory'],
+    nt: ['Northwest Territories', 'territory'],
+    yt: ['Yukon', 'territory']
+  }
+
+  async canCreate (username) {
+    return (username in ProvinceBotFactory.#provinces)
+  }
+
+  async create (username) {
+    if (!(username in ProvinceBotFactory.#provinces)) {
+      throw new Error(`cannot create a bot with username ${username}`)
+    }
+    const [name, type] = ProvinceBotFactory.#provinces[username]
+    const bot = new ProvinceBot(username, name, type)
+    await bot.initialize(await this._context.duplicate(username))
+    return bot
+  }
+}

package/tests/httpsignature.test.js

@@ -1,11 +1,11 @@
 import { describe, before, after, it } from 'node:test'
 import assert from 'node:assert'
 import { Sequelize } from 'sequelize'
-import { KeyStorage } from '../lib/keystorage.js'
 import { nockSetup, nockSignature, nockKeyRotate, getPublicKey, getPrivateKey, nockFormat } 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'
 
 describe('HTTPSignature', async () => {
   const domain = 'activitypubbot.example'
@@ -18,10 +18,9 @@ describe('HTTPSignature', async () => {
     logger = Logger({
       level: 'silent'
     })
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
-    const keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
+    await runMigrations(connection)
     nockSetup('social.example')
     digester = new Digester(logger)
   })

package/tests/httpsignatureauthenticator.test.js

@@ -11,6 +11,7 @@ import { RemoteKeyStorage } from '../lib/remotekeystorage.js'
 import { ActivityPubClient } from '../lib/activitypubclient.js'
 import { UrlFormatter } from '../lib/urlformatter.js'
 import as2 from '../lib/activitystreams.js'
+import { runMigrations } from '../lib/migrations/index.js'
 
 describe('HTTPSignatureAuthenticator', async () => {
   const domain = 'activitypubbot.example'
@@ -39,16 +40,15 @@ describe('HTTPSignatureAuthenticator', 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)
     signer = new HTTPSignature(logger)
     digester = new Digester(logger)
     const formatter = new UrlFormatter(origin)
     const keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
     const client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
     remoteKeyStorage = new RemoteKeyStorage(client, connection, logger)
-    await remoteKeyStorage.initialize()
     nockSetup('social.example')
   })
 

package/tests/index.test.js

@@ -0,0 +1,10 @@
+import assert from 'node:assert'
+import { describe, it } from 'node:test'
+describe('package exports', () => {
+  it('exposes Bot, BotFactory, and makeApp', async () => {
+    const { Bot, BotFactory, makeApp } = await import('../lib/index.js')
+    assert.equal(typeof Bot, 'function')
+    assert.equal(typeof BotFactory, 'function')
+    assert.equal(typeof makeApp, 'function')
+  })
+})