@evanp/activitypub-bot 0.8.0 → 0.11.0

package/tests/activityhandler.test.js

@@ -17,6 +17,9 @@ import bots from './fixtures/bots.js'
 import { nockSetup, postInbox, makeActor, nockFormat } from './utils/nock.js'
 import { Digester } from '../lib/digester.js'
 import { HTTPSignature } from '../lib/httpsignature.js'
+import { runMigrations } from '../lib/migrations/index.js'
+import { BotContext } from '../lib/botcontext.js'
+import { Transformer } from '../lib/microsyntax.js'
 
 describe('ActivityHandler', () => {
   const domain = 'activitypubbot.example'
@@ -36,27 +39,46 @@ describe('ActivityHandler', () => {
   let botId = null
   const botName = 'ok'
   let bot = null
+  const loggerBotName = 'logging'
+  let lb = null
+  let lbId = null
+  let transformer = null
   before(async () => {
     logger = Logger({ level: 'silent' })
     formatter = new UrlFormatter(origin)
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     botDataStorage = new BotDataStorage(connection)
-    await botDataStorage.initialize()
     objectStorage = new ObjectStorage(connection)
-    await objectStorage.initialize()
     keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
     actorStorage = new ActorStorage(connection, formatter)
-    await actorStorage.initialize()
     const signer = new HTTPSignature(logger)
     const digester = new Digester(logger)
     client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
     distributor = new ActivityDistributor(client, formatter, actorStorage, logger)
     authz = new Authorizer(actorStorage, formatter, client)
     cache = new ObjectCache({ longTTL: 3600 * 1000, shortTTL: 300 * 1000, maxItems: 1000 })
+    transformer = new Transformer(`${origin}/tag/`, client)
+    await Promise.all(
+      Object.values(bots).map(bot => bot.initialize(
+        new BotContext(
+          bot.username,
+          botDataStorage,
+          objectStorage,
+          actorStorage,
+          client,
+          distributor,
+          formatter,
+          transformer,
+          logger
+        )
+      ))
+    )
     botId = formatter.format({ username: botName })
+    lbId = formatter.format({ username: loggerBotName })
     bot = bots[botName]
+    lb = bots[loggerBotName]
     await objectStorage.create(await as2.import({
       id: formatter.format({ username: 'test1', type: 'object', nanoid: '_pEWsKke-7lACTdM3J_qd' }),
       type: 'Object',
@@ -299,6 +321,19 @@ describe('ActivityHandler', () => {
     await handler.onIdle()
     assert.ok(!postInbox.follower3)
   })
+  it('notifies the bot of a follow activity', async () => {
+    const actor = await makeActor('follower4')
+    const activity = await as2.import({
+      type: 'Follow',
+      id: 'https://social.example/user/follower4/follow/1',
+      actor: actor.id,
+      object: lbId,
+      to: lbId
+    })
+    await handler.handleActivity(lb, activity)
+    assert.ok(lb.follows.has(activity.id))
+    await handler.onIdle()
+  })
   it('can handle an accept activity', async () => {
     const actor = await makeActor('accepter1')
     const followActivity = await as2.import({
@@ -811,6 +846,34 @@ describe('ActivityHandler', () => {
       await objectStorage.isInCollection(note.id, 'likes', activity2)
     )
   })
+  it('notifies the bot of a like activity', async () => {
+    const actor = await makeActor('liker9')
+    const note = await as2.import({
+      attributedTo: lbId,
+      id: formatter.format({
+        username: loggerBotName,
+        type: 'note',
+        nanoid: 'IGeAucyHD-s3Ywg9X9sCo'
+      }),
+      type: 'Note',
+      content: 'Hello, world!',
+      to: 'as:Public'
+    })
+    await objectStorage.create(note)
+    const activity = await as2.import({
+      type: 'Like',
+      actor: actor.id,
+      id: nockFormat({
+        username: 'liker9',
+        type: 'Like',
+        nanoid: '3fKK6LcMtqrAp1Ekn471u'
+      }),
+      object: note.id,
+      to: [lbId, 'as:Public']
+    })
+    await handler.handleActivity(lb, activity)
+    assert.ok(lb.likes.has(activity.id))
+  })
   it('can handle an announce activity', async () => {
     const actor = await makeActor('announcer1')
     const note = await as2.import({
@@ -1017,6 +1080,34 @@ describe('ActivityHandler', () => {
       await objectStorage.isInCollection(note.id, 'shares', activity2)
     )
   })
+  it('notifies the bot on an announce activity', async () => {
+    const actor = await makeActor('announcer9')
+    const note = await as2.import({
+      attributedTo: lbId,
+      id: formatter.format({
+        username: loggerBotName,
+        type: 'note',
+        nanoid: 'LNCVgovrjpA6oSKnGDax2'
+      }),
+      type: 'Note',
+      content: 'Hello, world!',
+      to: 'as:Public'
+    })
+    await objectStorage.create(note)
+    const activity = await as2.import({
+      type: 'Announce',
+      actor: actor.id,
+      id: nockFormat({
+        username: 'announcer9',
+        type: 'Announce',
+        nanoid: 'LmVvlEBHNf2X6nfgzMe6F'
+      }),
+      object: note.id,
+      to: [lbId, 'as:Public']
+    })
+    await handler.handleActivity(lb, activity)
+    assert.ok(lb.shares.has(activity.id))
+  })
   it('can handle a block activity', async () => {
     const actor = await makeActor('blocker1')
     await actorStorage.addToCollection(botName, 'followers', actor)

package/tests/activitypubclient.test.js

@@ -4,128 +4,62 @@ import { UrlFormatter } from '../lib/urlformatter.js'
 import { ActivityPubClient } from '../lib/activitypubclient.js'
 import assert from 'node:assert'
 import { Sequelize } from 'sequelize'
-import nock from 'nock'
 import as2 from '../lib/activitystreams.js'
 import Logger from 'pino'
 import { HTTPSignature } from '../lib/httpsignature.js'
 import { Digester } from '../lib/digester.js'
-
-const makeActor = (username) =>
-  as2.import({
-    id: `https://social.example/user/${username}`,
-    type: 'Person',
-    preferredUsername: username,
-    inbox: `https://social.example/user/${username}/inbox`,
-    outbox: `https://social.example/user/${username}/outbox`,
-    followers: `https://social.example/user/${username}/followers`,
-    following: `https://social.example/user/${username}/following`,
-    liked: `https://social.example/user/${username}/liked`,
-    publicKey: {
-      id: `https://social.example/user/${username}/publickey`,
-      owner: `https://social.example/user/${username}`,
-      type: 'CryptographicKey',
-      publicKeyPem: '-----BEGIN PUBLIC KEY-----\nFAKEFAKEFAKE\n-----END PUBLIC KEY-----'
-    }
-  })
-
-const makeKey = (username) =>
-  as2.import({
-    id: `https://social.example/user/${username}/publickey`,
-    owner: `https://social.example/user/${username}`,
-    type: 'CryptographicKey',
-    publicKeyPem: '-----BEGIN PUBLIC KEY-----\nFAKEFAKEFAKE\n-----END PUBLIC KEY-----'
-  })
-
-const makeNote = (username, num) =>
-  as2.import({
-    id: `https://social.example/user/${username}/note/${num}`,
-    type: 'Object',
-    attributedTo: `https://social.example/user/${username}`,
-    to: 'https://www.w3.org/ns/activitystreams#Public',
-    content: `This is note ${num} by ${username}.`
-  })
+import { runMigrations } from '../lib/migrations/index.js'
+import {
+  nockSetup,
+  getRequestHeaders,
+  resetRequestHeaders,
+  addToCollection,
+  nockFormat
+} from './utils/nock.js'
 
 describe('ActivityPubClient', async () => {
   let connection = null
   let keyStorage = null
   let formatter = null
   let client = null
-  let postInbox = null
-  let signature = null
-  let digest = null
-  let date = null
   let signer = null
   let digester = null
   let logger = null
+  const remoteUser = 'remote1'
+  const remoteCollection = 1
+  const remoteOrderedCollection = 2
+  const remotePagedCollection = 3
+  const remotePagedOrderedCollection = 4
+  const maxItems = 10
   before(async () => {
     logger = new Logger({
       level: 'silent'
     })
     digester = new Digester(logger)
     signer = new HTTPSignature(logger)
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
     formatter = new UrlFormatter('https://activitypubbot.example')
-    const remote = 'https://social.example'
-    nock(remote)
-      .get(/\/user\/(\w+)$/)
-      .reply(async function (uri, requestBody) {
-        const headers = this.req.headers
-        signature[remote + uri] = headers.signature
-        digest[remote + uri] = headers.digest
-        date[remote + uri] = headers.date
-        const username = uri.match(/\/user\/(\w+)$/)[1]
-        const actor = await makeActor(username)
-        const actorText = await actor.write()
-        return [200, actorText, { 'Content-Type': 'application/activity+json' }]
-      })
-      .persist()
-      .post(/\/user\/(\w+)\/inbox$/)
-      .reply(async function (uri, requestBody) {
-        const headers = this.req.headers
-        signature[remote + uri] = headers.signature
-        digest[remote + uri] = headers.digest
-        date[remote + uri] = headers.date
-        const username = uri.match(/\/user\/(\w+)\/inbox$/)[1]
-        if (username in postInbox) {
-          postInbox[username] += 1
-        } else {
-          postInbox[username] = 1
-        }
-        return [202, 'accepted']
-      })
-      .persist()
-      .get(/\/user\/(\w+)\/note\/(\d+)$/)
-      .reply(async function (uri, requestBody) {
-        const headers = this.req.headers
-        signature[remote + uri] = headers.signature
-        digest[remote + uri] = headers.digest
-        date[remote + uri] = headers.date
-        const match = uri.match(/\/user\/(\w+)\/note\/(\d+)$/)
-        const username = match[1]
-        const num = match[2]
-        const obj = await makeNote(username, num)
-        const objText = await obj.write()
-        return [200, objText, { 'Content-Type': 'application/activity+json' }]
-      })
-      .get(/\/user\/(\w+)\/inbox$/)
-      .reply(async function (uri, requestBody) {
-        return [403, 'Forbidden', { 'Content-Type': 'text/plain' }]
-      })
-      .get(/\/user\/(\w+)\/publickey$/)
-      .reply(async function (uri, requestBody) {
-        const headers = this.req.headers
-        signature[remote + uri] = headers.signature
-        digest[remote + uri] = headers.digest
-        date[remote + uri] = headers.date
-        const username = uri.match(/\/user\/(\w+)\/publickey$/)[1]
-        const key = await makeKey(username)
-        const keyText = await key.write()
-        return [200, keyText, { 'Content-Type': 'application/activity+json' }]
-      })
-      .persist()
+    const remote = 'social.example'
+    nockSetup(remote, logger)
+    for (let i = 0; i < maxItems; i++) {
+      const id = nockFormat({ username: remoteUser, type: 'note', num: i })
+      addToCollection(remoteUser, remoteCollection, id, remote)
+    }
+    for (let i = maxItems; i < 2 * maxItems; i++) {
+      const id = nockFormat({ username: remoteUser, type: 'note', num: i })
+      addToCollection(remoteUser, remoteOrderedCollection, id, remote)
+    }
+    for (let i = 2 * maxItems; i < 7 * maxItems; i++) {
+      const id = nockFormat({ username: remoteUser, type: 'note', num: i })
+      addToCollection(remoteUser, remotePagedCollection, id, remote)
+    }
+    for (let i = 7 * maxItems; i < 12 * maxItems; i++) {
+      const id = nockFormat({ username: remoteUser, type: 'note', num: i })
+      addToCollection(remoteUser, remotePagedOrderedCollection, id, remote)
+    }
   })
   after(async () => {
     await connection.close()
@@ -133,17 +67,12 @@ describe('ActivityPubClient', async () => {
     connection = null
     formatter = null
     client = null
-    postInbox = null
-    signature = null
     logger = null
     digester = null
     signer = null
   })
   beforeEach(async () => {
-    signature = {}
-    digest = {}
-    postInbox = {}
-    date = {}
+    resetRequestHeaders()
   })
   it('can initialize', () => {
     client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
@@ -155,13 +84,14 @@ describe('ActivityPubClient', async () => {
     assert.ok(obj)
     assert.equal(typeof obj, 'object')
     assert.equal(obj.id, id)
-    assert.ok(signature[id])
-    assert.match(signature[id], /^keyId="https:\/\/activitypubbot\.example\/user\/foobot\/publickey",headers="\(request-target\) host date user-agent accept",signature=".*",algorithm="rsa-sha256"$/)
-    assert.equal(typeof digest[id], 'undefined')
-    assert.equal(typeof date[id], 'string')
-    assert.match(date[id], /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
+    const h = getRequestHeaders(id)
+    assert.ok(h.signature)
+    assert.match(h.signature, /^keyId="https:\/\/activitypubbot\.example\/user\/foobot\/publickey",headers="\(request-target\) host date user-agent accept",signature=".*",algorithm="rsa-sha256"$/)
+    assert.equal(typeof h.digest, 'undefined')
+    assert.equal(typeof h.date, 'string')
+    assert.match(h.date, /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
     assert.doesNotThrow(() => {
-      Date.parse(date[id])
+      Date.parse(h.date)
     })
   })
   it('can get a remote object without a username', async () => {
@@ -170,13 +100,14 @@ describe('ActivityPubClient', async () => {
     assert.ok(obj)
     assert.equal(typeof obj, 'object')
     assert.equal(obj.id, id)
-    assert.ok(signature[id])
-    assert.match(signature[id], /^keyId="https:\/\/activitypubbot\.example\/publickey",headers="\(request-target\) host date user-agent accept",signature=".*",algorithm="rsa-sha256"$/)
-    assert.equal(typeof digest[id], 'undefined')
-    assert.equal(typeof date[id], 'string')
-    assert.match(date[id], /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
+    const h = getRequestHeaders(id)
+    assert.ok(h.signature)
+    assert.match(h.signature, /^keyId="https:\/\/activitypubbot\.example\/publickey",headers="\(request-target\) host date user-agent accept",signature=".*",algorithm="rsa-sha256"$/)
+    assert.equal(typeof h.digest, 'undefined')
+    assert.equal(typeof h.date, 'string')
+    assert.match(h.date, /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
     assert.doesNotThrow(() => {
-      Date.parse(date[id])
+      Date.parse(h.date)
     })
   })
   it('can get a remote key without a signature', async () => {
@@ -185,12 +116,13 @@ describe('ActivityPubClient', async () => {
     assert.ok(obj)
     assert.equal(typeof obj, 'object')
     assert.equal(obj.id, id)
-    assert.equal(signature[id], undefined)
-    assert.equal(typeof digest[id], 'undefined')
-    assert.equal(typeof date[id], 'string')
-    assert.match(date[id], /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
+    const h = getRequestHeaders(id)
+    assert.equal(h.signature, undefined)
+    assert.equal(typeof h.digest, 'undefined')
+    assert.equal(typeof h.date, 'string')
+    assert.match(h.date, /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
     assert.doesNotThrow(() => {
-      Date.parse(date[id])
+      Date.parse(h.date)
     })
   })
   it('can deliver an activity', async () => {
@@ -202,14 +134,15 @@ describe('ActivityPubClient', async () => {
       .get()
     const inbox = 'https://social.example/user/evan/inbox'
     await client.post(inbox, obj, 'foobot')
-    assert.ok(signature[inbox])
-    assert.ok(digest[inbox])
-    assert.match(signature[inbox], /^keyId="https:\/\/activitypubbot\.example\/user\/foobot\/publickey",headers="\(request-target\) host date user-agent content-type digest",signature=".*",algorithm="rsa-sha256"$/)
-    assert.match(digest[inbox], /^sha-256=[0-9a-zA-Z=+/]*$/)
-    assert.equal(typeof date[inbox], 'string')
-    assert.match(date[inbox], /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
+    const h = getRequestHeaders(inbox)
+    assert.ok(h.signature)
+    assert.ok(h.digest)
+    assert.match(h.signature, /^keyId="https:\/\/activitypubbot\.example\/user\/foobot\/publickey",headers="\(request-target\) host date user-agent content-type digest",signature=".*",algorithm="rsa-sha256"$/)
+    assert.match(h.digest, /^sha-256=[0-9a-zA-Z=+/]*$/)
+    assert.equal(typeof h.date, 'string')
+    assert.match(h.date, /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/)
     assert.doesNotThrow(() => {
-      Date.parse(date[inbox])
+      Date.parse(h.date)
     })
   })
   it('throws an error on a non-2xx response', async () => {
@@ -222,4 +155,56 @@ describe('ActivityPubClient', async () => {
       assert.equal(error.status, 403)
     }
   })
+  it('can iterate over a Collection', async () => {
+    const collectionUri = nockFormat({
+      username: remoteUser,
+      type: 'Collection',
+      num: remoteCollection
+    })
+    let counter = 0
+    for await (const item of client.items(collectionUri)) {
+      assert.ok(item)
+      counter = counter + 1
+    }
+    assert.strictEqual(counter, maxItems)
+  })
+  it('can iterate over an OrderedCollection', async () => {
+    const collectionUri = nockFormat({
+      username: remoteUser,
+      type: 'OrderedCollection',
+      num: remoteOrderedCollection
+    })
+    let counter = 0
+    for await (const item of client.items(collectionUri)) {
+      assert.ok(item)
+      counter = counter + 1
+    }
+    assert.strictEqual(counter, maxItems)
+  })
+  it('can iterate over a paged Collection', async () => {
+    const collectionUri = nockFormat({
+      username: remoteUser,
+      type: 'PagedCollection', // Fake type
+      num: remotePagedCollection
+    })
+    let counter = 0
+    for await (const item of client.items(collectionUri)) {
+      assert.ok(item)
+      counter = counter + 1
+    }
+    assert.strictEqual(counter, 5 * maxItems)
+  })
+  it('can iterate over a paged OrderedCollection', async () => {
+    const collectionUri = nockFormat({
+      username: remoteUser,
+      type: 'PagedOrderedCollection', // Fake type
+      num: remotePagedOrderedCollection
+    })
+    let counter = 0
+    for await (const item of client.items(collectionUri)) {
+      assert.ok(item)
+      counter = counter + 1
+    }
+    assert.strictEqual(counter, 5 * maxItems)
+  })
 })

package/tests/actorstorage.test.js

@@ -4,6 +4,7 @@ import { ActorStorage } from '../lib/actorstorage.js'
 import { Sequelize } from 'sequelize'
 import { UrlFormatter } from '../lib/urlformatter.js'
 import as2 from '../lib/activitystreams.js'
+import { runMigrations } from '../lib/migrations/index.js'
 
 const AS2_NS = 'https://www.w3.org/ns/activitystreams#'
 
@@ -12,14 +13,20 @@ describe('ActorStorage', () => {
   let storage = null
   let formatter = null
   let other = null
+  let unfollowed = null
   before(async () => {
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     formatter = new UrlFormatter('https://activitypubbot.example')
     other = await as2.import({
       id: 'https://social.example/user/test2',
       type: 'Person'
     })
+    unfollowed = await as2.import({
+      id: 'https://social.example/user/test3',
+      type: 'Person'
+    })
   })
   after(async () => {
     await connection.close()
@@ -31,7 +38,6 @@ describe('ActorStorage', () => {
     assert.ok(storage instanceof ActorStorage)
   })
   it('can initialize the storage', async () => {
-    await storage.initialize()
   })
   it('can get an actor', async () => {
     const actor = await storage.getActor('test')
@@ -252,10 +258,26 @@ describe('ActorStorage', () => {
     assert.strictEqual(actor.get('preferredUsername').first, 'test8')
     assert.strictEqual(actor.name.get(), 'Test User')
     assert.strictEqual(actor.summary.get(), 'A test user')
-    console.log(actor.type)
-    console.log(await actor.write())
     assert.ok(Array.isArray(actor.type))
     assert.ok(actor.type.includes(AS2_NS + 'Person'))
     assert.ok(actor.type.includes(AS2_NS + 'Service'))
   })
+
+  it('can get all actors with an object in a collection', async () => {
+    for (const i of [101, 102, 103, 104, 105]) {
+      await storage.addToCollection(`test${i}`, 'following', other)
+    }
+    const usernames = await storage.getUsernamesWith('following', other)
+    assert.strictEqual(usernames.length, 5)
+    assert.ok(usernames.includes('test101'))
+    assert.ok(usernames.includes('test102'))
+    assert.ok(usernames.includes('test103'))
+    assert.ok(usernames.includes('test104'))
+    assert.ok(usernames.includes('test105'))
+  })
+
+  it('gets zero usernames when an object is in no collection', async () => {
+    const usernames = await storage.getUsernamesWith('following', unfollowed)
+    assert.strictEqual(usernames.length, 0)
+  })
 })

package/tests/authorizer.test.js

@@ -3,7 +3,6 @@ import { Authorizer } from '../lib/authorizer.js'
 import { ActorStorage } from '../lib/actorstorage.js'
 import { Sequelize } from 'sequelize'
 import { UrlFormatter } from '../lib/urlformatter.js'
-import { ObjectStorage } from '../lib/objectstorage.js'
 import { KeyStorage } from '../lib/keystorage.js'
 import { ActivityPubClient } from '../lib/activitypubclient.js'
 import as2 from '../lib/activitystreams.js'
@@ -12,13 +11,13 @@ import { nanoid } from 'nanoid'
 import { HTTPSignature } from '../lib/httpsignature.js'
 import Logger from 'pino'
 import { Digester } from '../lib/digester.js'
+import { runMigrations } from '../lib/migrations/index.js'
 
 describe('Authorizer', () => {
   let authorizer = null
   let actorStorage = null
   let formatter = null
   let connection = null
-  let objectStorage = null
   let keyStorage = null
   let client = null
 
@@ -39,14 +38,11 @@ describe('Authorizer', () => {
       level: 'silent'
     })
     formatter = new UrlFormatter('https://activitypubbot.example')
-    connection = new Sequelize('sqlite::memory:', { logging: false })
+    connection = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
     await connection.authenticate()
+    await runMigrations(connection)
     actorStorage = new ActorStorage(connection, formatter)
-    await actorStorage.initialize()
-    objectStorage = new ObjectStorage(connection)
-    await objectStorage.initialize()
     keyStorage = new KeyStorage(connection, logger)
-    await keyStorage.initialize()
     const signer = new HTTPSignature(logger)
     const digester = new Digester(logger)
     client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
@@ -134,7 +130,6 @@ describe('Authorizer', () => {
     actorStorage = null
     connection = null
     authorizer = null
-    objectStorage = null
   })
 
   it('should be a class', async () => {