@evanp/activitypub-bot 0.13.0 → 0.13.2

package/tests/index.test.js

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

package/tests/keystorage.test.js

@@ -1,124 +0,0 @@
-import { describe, before, after, it } from 'node:test'
-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
-  let storage = null
-  let logger = null
-  let firstPublicKey = null
-  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({ dialect: 'sqlite', storage: ':memory:', logging: false })
-    await connection.authenticate()
-    await runMigrations(connection)
-    logger = new Logger({
-      level: 'silent'
-    })
-  })
-  after(async () => {
-    await connection.close()
-    connection = null
-    logger = null
-  })
-  it('can initialize', async () => {
-    storage = new KeyStorage(connection, logger)
-  })
-  it('can get a public key', async () => {
-    firstPublicKey = await storage.getPublicKey('test1')
-    assert.ok(firstPublicKey)
-    assert.equal(typeof firstPublicKey, 'string')
-    assert.match(firstPublicKey, /^-----BEGIN PUBLIC KEY-----\n/)
-    assert.match(firstPublicKey, /-----END PUBLIC KEY-----\n$/)
-  })
-  it('can get a public key again', async () => {
-    secondPublicKey = await storage.getPublicKey('test1')
-    assert.ok(secondPublicKey)
-    assert.equal(typeof secondPublicKey, 'string')
-    assert.match(secondPublicKey, /^-----BEGIN PUBLIC KEY-----\n/)
-    assert.match(secondPublicKey, /-----END PUBLIC KEY-----\n$/)
-    assert.equal(firstPublicKey, secondPublicKey)
-  })
-  it('can get a private key after getting a public key', async () => {
-    const privateKey = await storage.getPrivateKey('test1')
-    assert.ok(privateKey)
-    assert.equal(typeof privateKey, 'string')
-    assert.match(privateKey, /^-----BEGIN PRIVATE KEY-----\n/)
-    assert.match(privateKey, /-----END PRIVATE KEY-----\n$/)
-  })
-  it('can get a private key', async () => {
-    firstPrivateKey = await storage.getPrivateKey('test2')
-    assert.ok(firstPrivateKey)
-    assert.equal(typeof firstPrivateKey, 'string')
-    assert.match(firstPrivateKey, /^-----BEGIN PRIVATE KEY-----\n/)
-    assert.match(firstPrivateKey, /-----END PRIVATE KEY-----\n$/)
-  })
-  it('can get a private key again', async () => {
-    secondPrivateKey = await storage.getPrivateKey('test2')
-    assert.ok(secondPrivateKey)
-    assert.equal(typeof secondPrivateKey, 'string')
-    assert.match(secondPrivateKey, /^-----BEGIN PRIVATE KEY-----\n/)
-    assert.match(secondPrivateKey, /-----END PRIVATE KEY-----\n$/)
-    assert.equal(firstPrivateKey, secondPrivateKey)
-  })
-  it('can get a public key after getting a private key', async () => {
-    const publicKey = await storage.getPublicKey('test2')
-    assert.ok(publicKey)
-    assert.equal(typeof publicKey, 'string')
-    assert.match(publicKey, /^-----BEGIN PUBLIC KEY-----\n/)
-    assert.match(publicKey, /-----END PUBLIC KEY-----\n$/)
-  })
-  it('can get distinct public keys for distinct bots', async () => {
-    const publicKey = await storage.getPublicKey('test1')
-    const publicKey2 = await storage.getPublicKey('test2')
-    assert.ok(publicKey)
-    assert.ok(publicKey2)
-    assert.notEqual(publicKey, publicKey2)
-  })
-  it('can get distinct private keys for distinct bots', async () => {
-    const privateKey = await storage.getPrivateKey('test1')
-    const privateKey2 = await storage.getPrivateKey('test2')
-    assert.ok(privateKey)
-    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

@@ -1,123 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert'
-import { Sequelize } from 'sequelize'
-import { Transformer } from '../lib/microsyntax.js'
-import { UrlFormatter } from '../lib/urlformatter.js'
-import { KeyStorage } from '../lib/keystorage.js'
-import { ActivityPubClient } from '../lib/activitypubclient.js'
-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#'
-
-describe('microsyntax', async () => {
-  const tagNamespace = 'https://tags.example/tag/'
-  const origin = 'https://activitypubbot.example'
-
-  nockSetup('social.example')
-
-  const logger = Logger({
-    level: 'silent'
-  })
-  const digester = new Digester(logger)
-  const connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
-  await connection.authenticate()
-  await runMigrations(connection)
-  const keyStorage = new KeyStorage(connection, logger)
-  const formatter = new UrlFormatter(origin)
-  const signer = new HTTPSignature(logger)
-  const client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
-  const transformer = new Transformer(tagNamespace, client)
-
-  it('has transformer', () => {
-    assert.ok(transformer)
-  })
-
-  describe('transform tagless text', async () => {
-    const text = 'Hello, world!'
-    const { html } = await transformer.transform(text)
-    it('has output', () => {
-      assert.ok(html)
-    })
-    it('is the same as input', () => {
-      assert.equal(html, `<p>${text}</p>`)
-    })
-  })
-
-  describe('transform hashtag', async () => {
-    const text = 'Hello, World! #greeting'
-    const { html, tag } = await transformer.transform(text)
-    it('has html output', () => {
-      assert.ok(html)
-    })
-    it('has tag', () => {
-      assert.ok(tag)
-    })
-    it('has correct html', () => {
-      assert.equal(html, '<p>Hello, World! <a href="https://tags.example/tag/greeting">#greeting</a></p>')
-    })
-    it('has correct tag', () => {
-      assert.equal(tag.length, 1)
-      assert.equal(tag[0].type, AS2 + 'Hashtag')
-      assert.equal(tag[0].name, '#greeting')
-      assert.equal(tag[0].href, 'https://tags.example/tag/greeting')
-    })
-  })
-
-  describe('transform url', async () => {
-    const text = 'Please visit https://example.com for more information.'
-    const { html, tag } = await transformer.transform(text)
-    it('has html output', () => {
-      assert.ok(html)
-    })
-    it('has tag', () => {
-      assert.ok(tag)
-    })
-    it('has correct html', () => {
-      assert.equal(html, '<p>Please visit <a href="https://example.com">https://example.com</a> for more information.</p>')
-    })
-    it('has correct tag', () => {
-      assert.equal(tag.length, 0)
-    })
-  })
-
-  describe('transform url with fragment', async () => {
-    const text = 'Please visit https://example.com#fragment for more information.'
-    const { html, tag } = await transformer.transform(text)
-    it('has html output', () => {
-      assert.ok(html)
-    })
-    it('has tag', () => {
-      assert.ok(tag)
-    })
-    it('has correct html', () => {
-      assert.equal(html, '<p>Please visit <a href="https://example.com#fragment">https://example.com#fragment</a> for more information.</p>')
-    })
-    it('has correct tag', () => {
-      assert.equal(tag.length, 0)
-    })
-  })
-
-  describe('transform full mention', async () => {
-    const text = 'Hello, @world@social.example !'
-    const { html, tag } = await transformer.transform(text)
-    it('has html output', () => {
-      assert.ok(html)
-    })
-    it('has tag', () => {
-      assert.ok(tag)
-    })
-    it('has correct html', () => {
-      assert.equal(html, '<p>Hello, <a href="https://social.example/profile/world">@world@social.example</a> !</p>')
-    })
-    it('has correct tag', () => {
-      assert.equal(tag.length, 1)
-      assert.equal(tag[0].type, 'Mention')
-      assert.equal(tag[0].name, '@world@social.example')
-      assert.equal(tag[0].href, 'https://social.example/profile/world')
-    })
-  })
-})

package/tests/objectcache.test.js

@@ -1,133 +0,0 @@
-import { describe, it } from 'node:test'
-import { ObjectCache } from '../lib/objectcache.js'
-import assert from 'node:assert/strict'
-import as2 from '../lib/activitystreams.js'
-
-describe('ObjectCache', async () => {
-  let cache = null
-  const longTTL = 3600 * 1000
-  const shortTTL = 300 * 1000
-  const maxItems = 1000
-  const makeObject = (num) =>
-    as2.import({
-      id: `https://example.com/${num}`,
-      name: `Object ${num}`,
-      type: 'Object',
-      attributedTo: `https://example.com/user${num}`,
-      to: 'https://www.w3.org/ns/activitystreams#Public'
-    })
-  const makeCollection = (num) =>
-    as2.import({
-      id: `https://example.com/collection${num}`,
-      type: 'Collection',
-      name: `Collection ${num}`,
-      totalItems: 1
-    })
-
-  const object1 = await makeObject(1)
-  const object2 = await makeObject(2)
-  const object3 = await makeObject(3)
-  const object4 = await makeObject(4)
-  const object5 = await makeObject(5)
-  const badid = 'https://example.com/badid'
-  const badcoll = 'https://example.com/badcoll'
-  const collection1 = await makeCollection(1)
-  const collection2 = await makeCollection(2)
-  const collection3 = await makeCollection(3)
-
-  it('should be a class', async () => {
-    assert.strictEqual(typeof ObjectCache, 'function')
-  })
-
-  it('can be instantiated', async () => {
-    cache = new ObjectCache({ longTTL, shortTTL, maxItems })
-    assert.strictEqual(typeof cache, 'object')
-  })
-
-  it('can be initialized', async () => {
-    try {
-      await cache.initialize()
-      assert.ok(true)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('returns undefined if not found', async () => {
-    try {
-      const value = await cache.get(badid)
-      assert.strictEqual(value, undefined)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('can save', async () => {
-    try {
-      await cache.save(object1)
-      const dupe = await cache.get(object1.id)
-      assert.strictEqual(dupe.id, object1.id)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('can saveReceived', async () => {
-    try {
-      await cache.saveReceived(object2)
-      const dupe = await cache.get(object2.id)
-      assert.strictEqual(dupe.id, object2.id)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('can clear', async () => {
-    try {
-      await cache.save(object3)
-      await cache.clear(object3)
-      const dupe = await cache.get(object3.id)
-      assert.strictEqual(dupe, undefined)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('fails membership for unknown collection', async () => {
-    try {
-      const flag = await cache.isMember(collection3, badid)
-      assert.strictEqual(flag, undefined)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('fails membership for unknown object', async () => {
-    try {
-      const flag = await cache.isMember(badcoll, object4)
-      assert.strictEqual(flag, undefined)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('can saveMembership', async () => {
-    try {
-      await cache.saveMembership(collection1, object4)
-      const flag = await cache.isMember(collection1, object4)
-      assert.ok(flag)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-
-  it('can saveMembershipReceived', async () => {
-    try {
-      await cache.saveMembershipReceived(collection2, object5)
-      const flag = await cache.isMember(collection2, object5)
-      assert.ok(flag)
-    } catch (error) {
-      assert.fail(error)
-    }
-  })
-})

package/tests/objectstorage.test.js

@@ -1,149 +0,0 @@
-import { describe, it, before, after } from 'node:test'
-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
-  let doc2 = null
-  let doc3 = null
-  let connection = null
-  let storage = null
-  before(async () => {
-    doc = await as2.import({
-      '@context': 'https://www.w3.org/ns/activitystreams',
-      id: 'https://social.example/users/test/note/1',
-      type: 'Note',
-      name: 'test',
-      content: 'test'
-    })
-    doc2 = await as2.import({
-      '@context': 'https://www.w3.org/ns/activitystreams',
-      id: 'https://social.example/users/test/note/2',
-      type: 'Note',
-      name: 'test',
-      content: 'test',
-      inReplyTo: doc.id
-    })
-    doc3 = await as2.import({
-      '@context': 'https://www.w3.org/ns/activitystreams',
-      id: 'https://social.example/users/test/note/3',
-      type: 'Note',
-      name: 'test',
-      content: 'test'
-    })
-    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)
-  })
-  it('can create a new object', async () => {
-    await storage.create(doc)
-  })
-  it('can read a created object', async () => {
-    await storage.read(doc.id)
-  })
-  it('can update a created object', async () => {
-    const doc2 = await as2.import({
-      '@context': 'https://www.w3.org/ns/activitystreams',
-      id: 'https://social.example/users/test/note/1',
-      type: 'Note',
-      name: 'test2',
-      content: 'test2'
-    })
-    await storage.update(doc2)
-    const read = await storage.read(doc2.id)
-    assert.equal(read.name.get(), 'test2')
-  })
-  it('can delete a created object', async () => {
-    await storage.delete(doc)
-    try {
-      await storage.read(doc.id)
-      assert.fail('should not be able to read deleted object')
-    } catch (err) {
-      assert.ok(err instanceof NoSuchObjectError)
-    }
-  })
-  it('can get a collection', async () => {
-    const collection = await storage.getCollection(doc.id, 'replies')
-    assert.equal(typeof (collection), 'object')
-    assert.equal(typeof (collection.id), 'string')
-    assert.equal(collection.id, `${doc.id}/replies`)
-    assert.equal(collection.type, 'https://www.w3.org/ns/activitystreams#OrderedCollection')
-    assert.equal(collection.totalItems, 0)
-    assert.equal(collection.first.id, `${doc.id}/replies/1`)
-    assert.equal(collection.last.id, `${doc.id}/replies/1`)
-  })
-  it('can get a collection page', async () => {
-    const page = await storage.getCollectionPage(doc.id, 'replies', 1)
-    assert.equal(typeof page, 'object')
-    assert.equal(page.id, `${doc.id}/replies/1`)
-    assert.equal(page.type, 'https://www.w3.org/ns/activitystreams#OrderedCollectionPage')
-    assert.equal(page.partOf.id, `${doc.id}/replies`)
-    assert.ok(!page.next)
-    assert.ok(!page.prev)
-    assert.ok(!page.items)
-  })
-  it('can add to a collection', async () => {
-    await storage.addToCollection(doc.id, 'replies', doc2)
-    const page = await storage.getCollectionPage(doc.id, 'replies', 1)
-    assert.ok(Array.from(page.items).find(item => item.id === doc2.id))
-  })
-  it('can check collection membership', async () => {
-    assert.strictEqual(true, await storage.isInCollection(doc.id, 'replies', doc2))
-    assert.strictEqual(false, await storage.isInCollection(doc.id, 'replies', doc3))
-  })
-  it('can remove from a collection', async () => {
-    await storage.removeFromCollection(doc.id, 'replies', doc2)
-    const page = await storage.getCollectionPage(doc.id, 'replies', 1)
-    assert.ok(!page.items)
-  })
-  it('can add many items to a collection', async () => {
-    for (let i = 3; i < 103; i++) {
-      const reply = await as2.import({
-        '@context': 'https://www.w3.org/ns/activitystreams',
-        id: `https://social.example/users/test/note/${i}`,
-        type: 'Note',
-        name: 'test',
-        content: 'test',
-        inReplyTo: doc.id
-      })
-      await storage.addToCollection(doc.id, 'replies', reply)
-    }
-    const collection = await storage.getCollection(doc.id, 'replies')
-    assert.equal(collection.totalItems, 100)
-    assert.equal(collection.first.id, `${doc.id}/replies/5`)
-    assert.equal(collection.last.id, `${doc.id}/replies/1`)
-    const page = await storage.getCollectionPage(doc.id, 'replies', 3)
-    assert.ok(page.next)
-    // assert.ok(page.prev)
-    assert.ok(page.items)
-    const items = Array.from(page.items)
-    assert.equal(items.length, 20)
-    for (let i = 0; i < items.length; i++) {
-      assert.ok(items[i])
-      for (let j = i + 1; j < items.length; j++) {
-        assert.ok(items[j])
-        assert.ok(
-          items[i].id > items[j].id,
-          `item ${i} (${items[i].id}) <= item ${j} (${items[j].id})`
-        )
-      }
-    }
-  })
-  it('can iterate over a collection', async () => {
-    const seen = new Set()
-    for await (const item of storage.items(doc.id, 'replies')) {
-      assert.ok(!(item.id in seen))
-      seen.add(item.id)
-    }
-    assert.strictEqual(seen.size, 100)
-  })
-})

package/tests/remotekeystorage.test.js

@@ -1,78 +0,0 @@
-import { describe, before, after, it } from 'node:test'
-import { RemoteKeyStorage } from '../lib/remotekeystorage.js'
-import assert from 'node:assert'
-import { Sequelize } from 'sequelize'
-import { KeyStorage } from '../lib/keystorage.js'
-import { UrlFormatter } from '../lib/urlformatter.js'
-import { ActivityPubClient } from '../lib/activitypubclient.js'
-import { nockSetup, nockFormat, getPublicKey, nockKeyRotate } 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('RemoteKeyStorage', async () => {
-  const host = 'activitypubbot.example'
-  const remoteHost = 'social.example'
-  const origin = `https://${host}`
-  let connection = null
-  let remoteKeyStorage = null
-  let client = null
-  let logger = null
-  before(async () => {
-    logger = Logger({
-      level: 'silent'
-    })
-    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
-    await connection.authenticate()
-    await runMigrations(connection)
-    const keyStorage = new KeyStorage(connection, logger)
-    const formatter = new UrlFormatter(origin)
-    const digester = new Digester(logger)
-    const signer = new HTTPSignature(logger)
-    client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
-    nockSetup(remoteHost)
-  })
-
-  after(async () => {
-    await connection.close()
-    logger = null
-  })
-
-  it('can initialize', async () => {
-    remoteKeyStorage = new RemoteKeyStorage(client, connection, logger)
-    assert.ok(remoteKeyStorage)
-    assert.ok(true)
-  })
-
-  it('can get a remote public key', async () => {
-    const username = 'test'
-    const domain = remoteHost
-    const id = nockFormat({ username, key: true, domain })
-    const publicKey = await getPublicKey(username, domain)
-    const remote = await remoteKeyStorage.getPublicKey(id)
-    assert.equal(remote.publicKeyPem, publicKey)
-  })
-
-  it('can get the same remote public key twice', async () => {
-    const username = 'test'
-    const domain = remoteHost
-    const id = nockFormat({ username, key: true, domain })
-    const publicKey = await getPublicKey(username, domain)
-    const remote = await remoteKeyStorage.getPublicKey(id)
-    assert.equal(remote.publicKeyPem, publicKey)
-  })
-
-  it('can get the right public key after key rotation', async () => {
-    const username = 'test'
-    const domain = remoteHost
-    const id = nockFormat({ username, key: true, domain })
-    const publicKey = await getPublicKey(username, domain)
-    const remote = await remoteKeyStorage.getPublicKey(id)
-    assert.equal(remote.publicKeyPem, publicKey)
-    await nockKeyRotate(username)
-    const publicKey2 = await getPublicKey(username, domain)
-    const remote2 = await remoteKeyStorage.getPublicKey(id, false)
-    assert.equal(remote2.publicKeyPem, publicKey2)
-  })
-})