@evanp/activitypub-bot 0.8.0

package/tests/activitypubclient.test.js

@@ -0,0 +1,225 @@
+import { describe, before, after, it, beforeEach } from 'node:test'
+import { KeyStorage } from '../lib/keystorage.js'
+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}.`
+  })
+
+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
+  before(async () => {
+    logger = new Logger({
+      level: 'silent'
+    })
+    digester = new Digester(logger)
+    signer = new HTTPSignature(logger)
+    connection = new Sequelize('sqlite::memory:', { logging: false })
+    await connection.authenticate()
+    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()
+  })
+  after(async () => {
+    await connection.close()
+    keyStorage = null
+    connection = null
+    formatter = null
+    client = null
+    postInbox = null
+    signature = null
+    logger = null
+    digester = null
+    signer = null
+  })
+  beforeEach(async () => {
+    signature = {}
+    digest = {}
+    postInbox = {}
+    date = {}
+  })
+  it('can initialize', () => {
+    client = new ActivityPubClient(keyStorage, formatter, signer, digester, logger)
+    assert.ok(client)
+  })
+  it('can get a remote object with a username', async () => {
+    const id = 'https://social.example/user/evan/note/1'
+    const obj = await client.get(id, 'foobot')
+    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$/)
+    assert.doesNotThrow(() => {
+      Date.parse(date[id])
+    })
+  })
+  it('can get a remote object without a username', async () => {
+    const id = 'https://social.example/user/evan/note/1'
+    const obj = await client.get(id)
+    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$/)
+    assert.doesNotThrow(() => {
+      Date.parse(date[id])
+    })
+  })
+  it('can get a remote key without a signature', async () => {
+    const id = 'https://social.example/user/evan/publickey'
+    const obj = await client.getKey(id)
+    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$/)
+    assert.doesNotThrow(() => {
+      Date.parse(date[id])
+    })
+  })
+  it('can deliver an activity', async () => {
+    const obj = as2.follow()
+      .actor('https://activitypubbot.example/user/foobot')
+      .object('https://social.example/user/evan')
+      .to('https://social.example/user/evan')
+      .publishedNow()
+      .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$/)
+    assert.doesNotThrow(() => {
+      Date.parse(date[inbox])
+    })
+  })
+  it('throws an error on a non-2xx response', async () => {
+    const inbox = 'https://social.example/user/evan/inbox'
+    try {
+      await client.get(inbox, 'foobot')
+      assert.fail('should have thrown')
+    } catch (error) {
+      assert.ok(error)
+      assert.equal(error.status, 403)
+    }
+  })
+})

package/tests/actorstorage.test.js

@@ -0,0 +1,261 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert'
+import { ActorStorage } from '../lib/actorstorage.js'
+import { Sequelize } from 'sequelize'
+import { UrlFormatter } from '../lib/urlformatter.js'
+import as2 from '../lib/activitystreams.js'
+
+const AS2_NS = 'https://www.w3.org/ns/activitystreams#'
+
+describe('ActorStorage', () => {
+  let connection = null
+  let storage = null
+  let formatter = null
+  let other = null
+  before(async () => {
+    connection = new Sequelize('sqlite::memory:', { logging: false })
+    await connection.authenticate()
+    formatter = new UrlFormatter('https://activitypubbot.example')
+    other = await as2.import({
+      id: 'https://social.example/user/test2',
+      type: 'Person'
+    })
+  })
+  after(async () => {
+    await connection.close()
+    connection = null
+    formatter = null
+  })
+  it('can create an instance', () => {
+    storage = new ActorStorage(connection, formatter)
+    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')
+    assert.ok(actor)
+    assert.ok(actor.id)
+    assert.ok(actor.inbox)
+    assert.ok(actor.outbox)
+    assert.ok(actor.followers)
+    assert.ok(actor.following)
+    assert.ok(actor.liked)
+    assert.strictEqual(actor.get('preferredUsername').first, 'test')
+  })
+
+  it('can get an actor by id', async () => {
+    const actor = await storage.getActorById('https://activitypubbot.example/user/test')
+    assert.ok(actor)
+    assert.ok(actor.id)
+    assert.ok(actor.inbox)
+    assert.ok(actor.outbox)
+    assert.ok(actor.followers)
+    assert.ok(actor.following)
+    assert.ok(actor.liked)
+    assert.strictEqual(actor.get('preferredUsername').first, 'test')
+  })
+  it('can get an empty collection', async () => {
+    const collection = await storage.getCollection('test', 'followers')
+    assert.ok(collection)
+    assert.strictEqual(collection.id, 'https://activitypubbot.example/user/test/followers')
+    assert.strictEqual(collection.type, 'https://www.w3.org/ns/activitystreams#OrderedCollection')
+    assert.strictEqual(collection.totalItems, 0)
+    assert.ok(collection.first)
+    assert.ok(collection.last)
+  })
+  it('can get an empty collection page', async () => {
+    const page = await storage.getCollectionPage('test', 'followers', 1)
+    assert.ok(page)
+    assert.strictEqual(
+      page.id,
+      'https://activitypubbot.example/user/test/followers/1'
+    )
+    assert.strictEqual(page.type, 'https://www.w3.org/ns/activitystreams#OrderedCollectionPage')
+    assert.strictEqual(
+      page.partOf.id,
+      'https://activitypubbot.example/user/test/followers'
+    )
+    assert.ok(!page.next)
+    assert.ok(!page.prev)
+  })
+  it('can add to a collection', async () => {
+    const collection = await storage.getCollection('test3', 'followers')
+    assert.strictEqual(collection.totalItems, 0)
+    await storage.addToCollection(
+      'test3',
+      'followers',
+      other
+    )
+    const collection2 = await storage.getCollection('test3', 'followers')
+    assert.strictEqual(collection2.totalItems, 1)
+    const page = await storage.getCollectionPage('test3', 'followers', 1)
+    assert.strictEqual(page.items.length, 1)
+    assert.strictEqual(Array.from(page.items)[0].id, 'https://social.example/user/test2')
+  })
+  it('can remove from a collection', async () => {
+    await storage.removeFromCollection(
+      'test3',
+      'followers',
+      other
+    )
+    const collection2 = await storage.getCollection('test3', 'followers')
+    assert.strictEqual(collection2.totalItems, 0)
+    const page = await storage.getCollectionPage('test3', 'followers', 1)
+    assert.ok(!page.items)
+  })
+  it('can add a lot of items a collection', async () => {
+    for (let i = 0; i < 100; i++) {
+      const other = await as2.import({
+        id: `https://social.example/user/foo/note/${i}`,
+        type: 'Note',
+        content: `Hello World ${i}`
+      })
+      await storage.addToCollection(
+        'test4',
+        'liked',
+        other
+      )
+    }
+    const collection = await storage.getCollection('test4', 'liked')
+    assert.strictEqual(collection.totalItems, 100)
+    const page = await storage.getCollectionPage('test4', 'liked', 3)
+    assert.strictEqual(page.items.length, 20)
+    assert.strictEqual(page.next.id, 'https://activitypubbot.example/user/test4/liked/2')
+  })
+  it('can iterate over a collection', async () => {
+    const seen = new Set()
+    for await (const item of storage.items('test4', 'liked')) {
+      assert.ok(!(item.id in seen))
+      seen.add(item.id)
+    }
+    assert.strictEqual(seen.size, 100)
+  })
+  it('can add twice and remove once from a collection', async () => {
+    const other = await as2.import({
+      id: 'https://social.example/user/foo/note/200',
+      type: 'Note',
+      content: 'Hello World 200'
+    })
+    const other2 = await as2.import({
+      id: 'https://social.example/user/foo/note/201',
+      type: 'Note',
+      content: 'Hello World 201'
+    })
+    const collection = await storage.getCollection('test5', 'liked')
+    assert.strictEqual(collection.totalItems, 0)
+    await storage.addToCollection(
+      'test5',
+      'liked',
+      other
+    )
+    await storage.addToCollection(
+      'test5',
+      'liked',
+      other2
+    )
+    const collection2 = await storage.getCollection('test5', 'liked')
+    assert.strictEqual(collection2.totalItems, 2)
+    await storage.removeFromCollection(
+      'test5',
+      'liked',
+      other
+    )
+    const collection3 = await storage.getCollection('test5', 'liked')
+    assert.strictEqual(collection3.totalItems, 1)
+  })
+  it('can check if something is in the collection', async () => {
+    const other = await as2.import({
+      id: 'https://social.example/user/foo/note/300',
+      type: 'Note',
+      content: 'Hello World 300'
+    })
+    const other2 = await as2.import({
+      id: 'https://social.example/user/foo/note/301',
+      type: 'Note',
+      content: 'Hello World 301'
+    })
+    let collection = await storage.getCollection('test6', 'liked')
+    assert.strictEqual(collection.totalItems, 0)
+    await storage.addToCollection(
+      'test6',
+      'liked',
+      other
+    )
+    collection = await storage.getCollection('test6', 'liked')
+    assert.strictEqual(collection.totalItems, 1)
+    assert.ok(await storage.isInCollection(
+      'test6',
+      'liked',
+      other
+    ))
+    assert.ok(!await storage.isInCollection(
+      'test6',
+      'liked',
+      other2
+    ))
+  })
+
+  it('retains totalItems when we remove an absent object', async () => {
+    const other = await as2.import({
+      id: 'https://social.example/user/foo/note/400',
+      type: 'Note',
+      content: 'Hello World 400'
+    })
+    const other2 = await as2.import({
+      id: 'https://social.example/user/foo/note/401',
+      type: 'Note',
+      content: 'Hello World 401'
+    })
+    const other3 = await as2.import({
+      id: 'https://social.example/user/foo/note/402',
+      type: 'Note',
+      content: 'Hello World 402'
+    })
+    let collection = await storage.getCollection('test7', 'liked')
+    assert.strictEqual(collection.totalItems, 0)
+    await storage.addToCollection(
+      'test7',
+      'liked',
+      other
+    )
+    await storage.addToCollection(
+      'test7',
+      'liked',
+      other2
+    )
+    collection = await storage.getCollection('test7', 'liked')
+    assert.strictEqual(collection.totalItems, 2)
+    await storage.removeFromCollection(
+      'test7',
+      'liked',
+      other3
+    )
+    collection = await storage.getCollection('test7', 'liked')
+    assert.strictEqual(collection.totalItems, 2)
+  })
+  it('can get an actor with custom properties', async () => {
+    const props = {
+      name: 'Test User',
+      summary: 'A test user',
+      type: 'Person'
+    }
+    const actor = await storage.getActor('test8', props)
+    assert.ok(actor)
+    assert.ok(actor.id)
+    assert.ok(actor.inbox)
+    assert.ok(actor.outbox)
+    assert.ok(actor.followers)
+    assert.ok(actor.following)
+    assert.ok(actor.liked)
+    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'))
+  })
+})

package/tests/app.test.js

@@ -0,0 +1,17 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { makeApp } from '../lib/app.js'
+import bots from './fixtures/bots.js'
+
+describe('app', async () => {
+  const databaseUrl = 'sqlite::memory:'
+  const origin = 'https://activitypubbot.test'
+  let app = null
+  it('should be a function', async () => {
+    assert.strictEqual(typeof makeApp, 'function')
+  })
+  it('should return a function', async () => {
+    app = await makeApp(databaseUrl, origin, bots, 'silent')
+    assert.strictEqual(typeof app, 'function')
+  })
+})