@evanp/activitypub-bot 0.13.0 → 0.13.2

package/tests/routes.sharedinbox.test.js

@@ -1,473 +0,0 @@
-import { describe, it, before } from 'node:test'
-import assert from 'node:assert'
-import as2 from '../lib/activitystreams.js'
-import request from 'supertest'
-
-import { makeApp } from '../lib/app.js'
-
-import {
-  nockSetup,
-  nockSignature,
-  nockFormat,
-  makeActor,
-  addFollower,
-  addFollowing,
-  addToCollection
-} from './utils/nock.js'
-import { makeDigest } from './utils/digest.js'
-import bots from './fixtures/bots.js'
-
-describe('routes.sharedinbox', async () => {
-  const host = 'activitypubbot.test'
-  const remoteHost = 'social.example'
-  const origin = `https://${host}`
-  const databaseUrl = 'sqlite::memory:'
-  let app = null
-  let formatter = null
-  let actorStorage = null
-
-  before(async () => {
-    nockSetup(remoteHost)
-    app = await makeApp(databaseUrl, origin, bots, 'silent')
-    formatter = app.locals.formatter
-    actorStorage = app.locals.actorStorage
-  })
-
-  describe('can handle an directly addressed activity', async () => {
-    const username = 'actor1'
-    const botName = 'test0'
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    before(async () => {
-      activity = await as2.import({
-        type: 'Activity',
-        actor: nockFormat({ username }),
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: formatter.format({ username: botName })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 () => {
-      assert.strictEqual(
-        true,
-        await actorStorage.isInCollection(
-          botName,
-          'inbox',
-          activity
-        )
-      )
-    })
-  })
-
-  describe('can handle an followers-only activity', async () => {
-    const username = 'actor2'
-    const botNames = ['test1', 'test2']
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      for (const botName of botNames) {
-        const botId = formatter.format({ username: botName })
-        addFollower(username, botId, remoteHost)
-        await actorStorage.addToCollection(botName, 'following', actor)
-      }
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: nockFormat({ username, collection: 'followers' })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      for (const botName of botNames) {
-        assert.strictEqual(
-          true,
-          await actorStorage.isInCollection(
-            botName,
-            'inbox',
-            activity
-          )
-        )
-      }
-    })
-  })
-
-  describe('can handle an public activity', async () => {
-    const username = 'actor3'
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: 'as:Public'
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      const lb = bots.logging
-      assert.ok(lb.publics.has(activity.id))
-    })
-  })
-
-  describe('can handle an activity to local followers collection', async () => {
-    const username = 'actor4'
-    const botNames = ['test3', 'test4', 'test5']
-    const followedBot = 'test6'
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      const followed = await as2.import({
-        id: formatter.format({ username: followedBot })
-      })
-      for (const botName of botNames) {
-        const botId = formatter.format({ username: botName })
-        const bot = await as2.import({ id: botId })
-        await actorStorage.addToCollection(followedBot, 'followers', bot)
-        await actorStorage.addToCollection(botName, 'following', followed)
-      }
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: formatter.format({ username: followedBot, collection: 'followers' })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      for (const botName of botNames) {
-        assert.strictEqual(
-          true,
-          await actorStorage.isInCollection(
-            botName,
-            'inbox',
-            activity
-          )
-        )
-      }
-    })
-  })
-
-  describe('can handle an activity to local following collection', async () => {
-    const username = 'actor5'
-    const botNames = ['test7', 'test8']
-    const followingBot = 'test9'
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      const following = await as2.import({
-        id: formatter.format({ username: followingBot })
-      })
-      for (const botName of botNames) {
-        const botId = formatter.format({ username: botName })
-        const bot = await as2.import({ id: botId })
-        await actorStorage.addToCollection(followingBot, 'following', bot)
-        await actorStorage.addToCollection(botName, 'followers', following)
-      }
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: formatter.format({
-          username: followingBot,
-          collection: 'following'
-        })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      for (const botName of botNames) {
-        assert.strictEqual(
-          true,
-          await actorStorage.isInCollection(
-            botName,
-            'inbox',
-            activity
-          )
-        )
-      }
-    })
-  })
-
-  describe('can handle an activity to remote following collection', async () => {
-    const username = 'actor6'
-    const botNames = ['test10', 'test11', 'test12']
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      for (const botName of botNames) {
-        const botId = formatter.format({ username: botName })
-        addFollowing(username, botId, remoteHost)
-        await actorStorage.addToCollection(botName, 'followers', actor)
-      }
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: nockFormat({ username, collection: 'following' })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      for (const botName of botNames) {
-        assert.strictEqual(
-          true,
-          await actorStorage.isInCollection(
-            botName,
-            'inbox',
-            activity
-          )
-        )
-      }
-    })
-  })
-
-  describe('can handle an activity to remote actor collection', async () => {
-    const username = 'actor7'
-    const botNames = ['test13', 'test14', 'test15']
-    const path = '/shared/inbox'
-    const url = `${origin}${path}`
-    const collection = 1
-    const date = new Date().toUTCString()
-    let response = null
-    let signature = null
-    let body = null
-    let digest = null
-    let activity = null
-    let actor = null
-    before(async () => {
-      actor = await makeActor(username, remoteHost)
-      for (const botName of botNames) {
-        const botId = formatter.format({ username: botName })
-        addToCollection(username, collection, botId, remoteHost)
-      }
-      activity = await as2.import({
-        type: 'Activity',
-        actor: actor.id,
-        id: nockFormat({ username, type: 'activity', num: 1 }),
-        to: nockFormat({ username, type: 'collection', num: collection })
-      })
-      body = await activity.write()
-      digest = makeDigest(body)
-      signature = await nockSignature({
-        method: 'POST',
-        username,
-        url,
-        digest,
-        date
-      })
-    })
-    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 all inboxes', async () => {
-      for (const botName of botNames) {
-        assert.strictEqual(
-          true,
-          await actorStorage.isInCollection(
-            botName,
-            'inbox',
-            activity
-          )
-        )
-      }
-    })
-  })
-})

package/tests/routes.webfinger.test.js

@@ -1,68 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert'
-import { makeApp } from '../lib/app.js'
-import request from 'supertest'
-import bots from './fixtures/bots.js'
-
-describe('webfinger routes', async () => {
-  const databaseUrl = 'sqlite::memory:'
-  const origin = 'https://activitypubbot.test'
-  const app = await makeApp(databaseUrl, origin, bots, 'silent')
-  describe('GET /.well-known/webfinger', async () => {
-    let response = null
-    it('should work without an error', async () => {
-      response = await request(app).get('/.well-known/webfinger?resource=acct%3Aok%40activitypubbot.test')
-    })
-    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:ok@activitypubbot.test')
-    })
-    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.test/user/ok')
-    })
-  })
-  describe('Webfinger discovery for non-existent user', async () => {
-    let response = null
-    it('should work without an error', async () => {
-      response = await request(app).get('/.well-known/webfinger?resource=acct%3Adne%40activitypubbot.test')
-    })
-    it('should return 404 Not Found', async () => {
-      assert.strictEqual(response.status, 404)
-    })
-  })
-  describe('Webfinger discovery for wrong domain', async () => {
-    let response = null
-    it('should work without an error', async () => {
-      response = await request(app).get('/.well-known/webfinger?resource=acct%3Adne%wrongdomain.test')
-    })
-    it('should return 400 Bad Request', async () => {
-      assert.strictEqual(response.status, 400)
-    })
-  })
-  describe('Webfinger discovery for HTTPS', async () => {
-    let response = null
-    it('should work without an error', async () => {
-      response = await request(app).get('/.well-known/webfinger?resource=' + encodeURIComponent('https://activitypubbot.test/user/ok'))
-    })
-    it('should return 400 Bad Request', async () => {
-      assert.strictEqual(response.status, 400)
-    })
-  })
-})

package/tests/urlformatter.test.js

@@ -1,164 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert'
-import { UrlFormatter } from '../lib/urlformatter.js'
-
-describe('UrlFormatter', () => {
-  const origin = 'https://activitypubbot.example'
-  let formatter = null
-  it('can initialize', () => {
-    formatter = new UrlFormatter(origin)
-  })
-  it('can format a user URL', () => {
-    const url = formatter.format({ username: 'megabot' })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot')
-  })
-  it('can format a public key URL', () => {
-    const url = formatter.format({ username: 'megabot', type: 'publickey' })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/publickey')
-  })
-  it('can format an inbox URL', () => {
-    const url = formatter.format({ username: 'megabot', collection: 'inbox' })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/inbox')
-  })
-  it('can format an inbox URL page', () => {
-    const url = formatter.format({
-      username: 'megabot',
-      collection: 'inbox',
-      page: 3
-    })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/inbox/3')
-  })
-  it('can format an activity URL', () => {
-    const url = formatter.format({
-      username: 'megabot',
-      type: 'like',
-      nanoid: 'LNPUlv9kmvhAdr4eoqkil'
-    })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/like/LNPUlv9kmvhAdr4eoqkil')
-  })
-  it('can format a note URL', () => {
-    const url = formatter.format({
-      username: 'megabot',
-      type: 'note',
-      nanoid: 'LNPUlv9kmvhAdr4eoqkil'
-    })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil')
-  })
-  it('can format a note replies URL', () => {
-    const url = formatter.format({
-      username: 'megabot',
-      type: 'note',
-      nanoid: 'LNPUlv9kmvhAdr4eoqkil',
-      collection: 'replies'
-    })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil/replies')
-  })
-  it('can format a note replies page URL', () => {
-    const url = formatter.format({
-      username: 'megabot',
-      type: 'note',
-      nanoid: 'LNPUlv9kmvhAdr4eoqkil',
-      collection: 'replies',
-      page: 4
-    })
-    assert.equal(url, 'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil/replies/4')
-  })
-  it('can format a server URL', () => {
-    const url = formatter.format({
-      server: true
-    })
-    assert.equal(url, 'https://activitypubbot.example/')
-  })
-  it('can format a server public key URL', () => {
-    const url = formatter.format({
-      server: true,
-      type: 'publickey'
-    })
-    assert.equal(url, 'https://activitypubbot.example/publickey')
-  })
-  it('can tell if an URL is local', () => {
-    assert.ok(formatter.isLocal('https://activitypubbot.example/user/megabot'))
-    assert.ok(!formatter.isLocal('https://social.example/user/megabot'))
-  })
-  it('can get a username from a user URL', () => {
-    const username = formatter.getUserName('https://activitypubbot.example/user/megabot')
-    assert.equal(username, 'megabot')
-  })
-  it('refuses to unformat a remote URL', () => {
-    assert.throws(() => formatter.unformat(
-      'https://remote.example/some/unrelated/33/path/format'
-    ))
-  })
-  it('can unformat a user URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot'
-    )
-    assert.equal(parts.username, 'megabot')
-  })
-  it('can unformat a public key URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/publickey'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.type, 'publickey')
-  })
-  it('can unformat an inbox URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/inbox'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.collection, 'inbox')
-  })
-  it('can unformat an inbox page URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/inbox/3'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.collection, 'inbox')
-    assert.equal(parts.page, 3)
-  })
-  it('can unformat an activity URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/like/LNPUlv9kmvhAdr4eoqkil'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.type, 'like')
-    assert.equal(parts.nanoid, 'LNPUlv9kmvhAdr4eoqkil')
-  })
-  it('can unformat a note URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.type, 'note')
-    assert.equal(parts.nanoid, 'LNPUlv9kmvhAdr4eoqkil')
-  })
-  it('can unformat a note replies URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil/replies'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.type, 'note')
-    assert.equal(parts.nanoid, 'LNPUlv9kmvhAdr4eoqkil')
-    assert.equal(parts.collection, 'replies')
-  })
-  it('can unformat a note replies page URL', () => {
-    const parts = formatter.unformat(
-      'https://activitypubbot.example/user/megabot/note/LNPUlv9kmvhAdr4eoqkil/replies/4'
-    )
-    assert.equal(parts.username, 'megabot')
-    assert.equal(parts.type, 'note')
-    assert.equal(parts.nanoid, 'LNPUlv9kmvhAdr4eoqkil')
-    assert.equal(parts.collection, 'replies')
-    assert.equal(parts.page, 4)
-  })
-  it('can unformat a server URL', () => {
-    const parts = formatter.unformat('https://activitypubbot.example/')
-    assert.ok(parts.server)
-  })
-  it('can unformat a server public key URL', () => {
-    const parts = formatter.unformat('https://activitypubbot.example/publickey')
-    assert.ok(parts.server)
-    assert.equal(parts.type, 'publickey')
-  })
-})