@evanp/activitypub-bot 0.12.1 → 0.13.1

package/tests/botdatastorage.test.js

@@ -1,88 +0,0 @@
-import { describe, before, after, it } from 'node:test'
-import { BotDataStorage, NoSuchValueError } from '../lib/botdatastorage.js'
-import assert from 'node:assert'
-import { Sequelize } from 'sequelize'
-import { runMigrations } from '../lib/migrations/index.js'
-
-describe('BotDataStorage', async () => {
-  let connection = null
-  let storage = null
-  before(async () => {
-    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 BotDataStorage(connection)
-  })
-  it('can set a value', async () => {
-    await storage.set('test', 'key1', 'value1')
-  })
-  it('can get a value', async () => {
-    const value = await storage.get('test', 'key1')
-    assert.equal(value, 'value1')
-  })
-  it('knows if a value exists', async () => {
-    const flag = await storage.has('test', 'key1')
-    assert.ok(flag)
-  })
-  it('knows if a value does not exist', async () => {
-    const flag = await storage.has('test', 'nonexistent1')
-    assert.ok(!flag)
-  })
-  it('raises an error on a non-existent value', async () => {
-    try {
-      await storage.get('test', 'nonexistent2')
-      assert.fail('Did not raise an exception getting a nonexistent key')
-    } catch (e) {
-      assert.ok(e instanceof NoSuchValueError)
-    }
-  })
-  it('can delete a value', async () => {
-    await storage.delete('test', 'key1')
-  })
-  it('knows if a value has been deleted', async () => {
-    const flag = await storage.has('test', 'key1')
-    assert.ok(!flag)
-  })
-  it('raises an error on a deleted value', async () => {
-    try {
-      await storage.get('test', 'key1')
-      assert.fail('Did not raise an exception getting a deleted key')
-    } catch (e) {
-      assert.ok(e instanceof NoSuchValueError)
-    }
-  })
-  it('stores different data at different keys for the same bot', async () => {
-    await storage.set('test', 'key2', 'value2')
-    await storage.set('test', 'key3', 'value3')
-    const value2 = await storage.get('test', 'key2')
-    const value3 = await storage.get('test', 'key3')
-    assert.notEqual(value2, value3)
-  })
-  it('stores different data at the same key for different bots', async () => {
-    await storage.set('test2', 'key4', 'value4')
-    await storage.set('test3', 'key4', 'value5')
-    const value4 = await storage.get('test2', 'key4')
-    const value5 = await storage.get('test3', 'key4')
-    assert.notEqual(value4, value5)
-  })
-  it('can store numbers', async () => {
-    await storage.set('test', 'numberkey1', 23)
-    const value = await storage.get('test', 'numberkey1')
-    assert.equal(value, 23)
-  })
-  it('can store arrays', async () => {
-    await storage.set('test', 'arraykey1', [1, 2, 3])
-    const value = await storage.get('test', 'arraykey1')
-    assert.deepEqual(value, [1, 2, 3])
-  })
-  it('can store objects', async () => {
-    await storage.set('test', 'objectkey1', { a: 1, b: 2, c: 3 })
-    const value = await storage.get('test', 'objectkey1')
-    assert.deepEqual(value, { a: 1, b: 2, c: 3 })
-  })
-})

package/tests/botfactory.provincebotfactory.test.js

@@ -1,430 +0,0 @@
-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/digester.test.js

@@ -1,56 +0,0 @@
-import { describe, it, before, after } from 'node:test'
-import assert from 'node:assert'
-import Logger from 'pino'
-import { Digester } from '../lib/digester.js'
-
-describe('Digester', () => {
-  let digester = null
-  let logger = null
-
-  before(() => {
-    logger = new Logger({
-      level: 'silent'
-    })
-  })
-
-  after(async () => {
-    logger = null
-  })
-
-  it('can initialize', async () => {
-    digester = new Digester(logger)
-    assert.ok(digester)
-  })
-
-  it('can digest a string', async () => {
-    const text = 'Hello, world!'
-    const digest = await digester.digest(text)
-    assert.ok(digest)
-    assert.equal(digest, 'sha-256=MV9b23bQeMQ7isAGTkoBZGErH853yGk0W/yUx1iU7dM=')
-  })
-
-  it('can compare two equal digests', async () => {
-    const text = 'Hello, world!'
-    const digest1 = await digester.digest(text)
-    const digest2 = await digester.digest(text)
-    const result = await digester.equals(digest1, digest2)
-    assert.ok(result)
-  })
-
-  it('can compare two different digests', async () => {
-    const text1 = 'Hello, world!'
-    const text2 = 'Hello, world!!'
-    const digest1 = await digester.digest(text1)
-    const digest2 = await digester.digest(text2)
-    const result = await digester.equals(digest1, digest2)
-    assert.ok(!result)
-  })
-
-  it('can compare two digests that differ only in case of the algorithm', async () => {
-    const text = 'Hello, world!'
-    const digest1 = await digester.digest(text)
-    const digest2 = digest1.replace('sha-256', 'SHA-256')
-    const result = await digester.equals(digest1, digest2)
-    assert.ok(result)
-  })
-})

package/tests/fixtures/bots.js

@@ -1,27 +0,0 @@
-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'),
-  null: new DoNothingBot('null'),
-  test0: new DoNothingBot('test0'),
-  test1: new DoNothingBot('test1'),
-  test2: new DoNothingBot('test2'),
-  test3: new DoNothingBot('test3'),
-  test4: new DoNothingBot('test4'),
-  test5: new DoNothingBot('test5'),
-  test6: new DoNothingBot('test6'),
-  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

@@ -1,57 +0,0 @@
-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
-  }
-}