@evanp/activitypub-bot 0.13.0 → 0.13.1

package/tests/activitypubclient.test.js

@@ -1,210 +0,0 @@
-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 as2 from '../lib/activitystreams.js'
-import Logger from 'pino'
-import { HTTPSignature } from '../lib/httpsignature.js'
-import { Digester } from '../lib/digester.js'
-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 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({ dialect: 'sqlite', storage: ':memory:', logging: false })
-    await connection.authenticate()
-    await runMigrations(connection)
-    keyStorage = new KeyStorage(connection, logger)
-    formatter = new UrlFormatter('https://activitypubbot.example')
-    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()
-    keyStorage = null
-    connection = null
-    formatter = null
-    client = null
-    logger = null
-    digester = null
-    signer = null
-  })
-  beforeEach(async () => {
-    resetRequestHeaders()
-  })
-  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)
-    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(h.date)
-    })
-  })
-  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)
-    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(h.date)
-    })
-  })
-  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)
-    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(h.date)
-    })
-  })
-  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')
-    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(h.date)
-    })
-  })
-  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)
-    }
-  })
-  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

@@ -1,283 +0,0 @@
-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'
-import { runMigrations } from '../lib/migrations/index.js'
-
-const AS2_NS = 'https://www.w3.org/ns/activitystreams#'
-
-describe('ActorStorage', () => {
-  let connection = null
-  let storage = null
-  let formatter = null
-  let other = null
-  let unfollowed = null
-  before(async () => {
-    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()
-    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 () => {
-  })
-  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')
-    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/app.test.js

@@ -1,17 +0,0 @@
-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')
-  })
-})