microfed 0.0.12 → 0.0.14

package/test/live.test.js

@@ -0,0 +1,109 @@
+/**
+ * Live Federation Tests
+ * Tests against real Mastodon instances
+ *
+ * Run: node --test test/live.test.js
+ *
+ * Note: Requires network access. May fail if instances are down.
+ */
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { lookup, resolve, getActorUrl } from '../src/webfinger.js'
+import { parseActor, getActorId } from '../src/profile.js'
+
+describe('Live WebFinger Lookup', { timeout: 10000 }, () => {
+  test('lookup mastodon.social account', async () => {
+    // Using Gargron (Mastodon creator) as a stable test account
+    const webfinger = await lookup('Gargron@mastodon.social')
+
+    assert.ok(webfinger.subject, 'missing subject')
+    assert.ok(webfinger.links, 'missing links')
+
+    const actorUrl = getActorUrl(webfinger)
+    assert.ok(actorUrl, 'no actor URL found')
+    assert.ok(actorUrl.includes('mastodon.social'), 'unexpected actor URL')
+  })
+
+  test('lookup returns valid JRD structure', async () => {
+    const webfinger = await lookup('Gargron@mastodon.social')
+
+    // Validate JRD structure
+    assert.ok(webfinger.subject.startsWith('acct:'))
+
+    const selfLink = webfinger.links.find(l =>
+      l.rel === 'self' && l.type === 'application/activity+json'
+    )
+    assert.ok(selfLink, 'missing ActivityPub self link')
+    assert.ok(selfLink.href.startsWith('https://'))
+  })
+})
+
+describe('Live Actor Fetch', { timeout: 10000 }, () => {
+  test('resolve mastodon.social actor', async () => {
+    const actor = await resolve('Gargron@mastodon.social')
+
+    // Validate required ActivityPub fields
+    assert.ok(actor.id, 'missing id')
+    assert.ok(actor.type, 'missing type')
+    assert.ok(actor.inbox, 'missing inbox')
+    assert.ok(actor.outbox, 'missing outbox')
+    assert.ok(actor.preferredUsername, 'missing preferredUsername')
+  })
+
+  test('actor has publicKey for signatures', async () => {
+    const actor = await resolve('Gargron@mastodon.social')
+
+    assert.ok(actor.publicKey, 'missing publicKey')
+    assert.ok(actor.publicKey.id, 'missing publicKey.id')
+    assert.ok(actor.publicKey.publicKeyPem, 'missing publicKeyPem')
+    assert.ok(
+      actor.publicKey.publicKeyPem.includes('BEGIN PUBLIC KEY'),
+      'publicKeyPem not in PEM format'
+    )
+  })
+
+  test('actor type is Person', async () => {
+    const actor = await resolve('Gargron@mastodon.social')
+    assert.strictEqual(actor.type, 'Person')
+  })
+
+  test('can extract actor ID', async () => {
+    const actor = await resolve('Gargron@mastodon.social')
+    const id = getActorId(actor)
+
+    assert.ok(id.startsWith('https://'))
+    assert.ok(id.includes('mastodon.social'))
+  })
+})
+
+describe('Live Outbox Fetch', { timeout: 10000 }, () => {
+  test('can fetch actor outbox', async () => {
+    const actor = await resolve('Gargron@mastodon.social')
+
+    const response = await fetch(actor.outbox, {
+      headers: { 'Accept': 'application/activity+json' }
+    })
+
+    assert.strictEqual(response.status, 200)
+
+    const outbox = await response.json()
+    assert.ok(
+      outbox.type === 'OrderedCollection' || outbox.type === 'OrderedCollectionPage',
+      'outbox must be OrderedCollection'
+    )
+    assert.ok(typeof outbox.totalItems === 'number', 'missing totalItems')
+  })
+})
+
+describe('Cross-instance Federation', { timeout: 15000 }, () => {
+  test('can lookup account on hachyderm.io', async () => {
+    // Test a different instance to verify federation lookup works
+    // Using a known active account
+    const webfinger = await lookup('nova@hachyderm.io')
+
+    assert.ok(webfinger.subject)
+    const actorUrl = getActorUrl(webfinger)
+    assert.ok(actorUrl.includes('hachyderm.io'))
+  })
+})

package/test/mastodon.test.js

@@ -0,0 +1,243 @@
+/**
+ * Mastodon Compatibility Tests
+ * Tests that our output matches Mastodon's expected format
+ *
+ * Run: node --test test/mastodon.test.js
+ */
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { createActor } from '../src/profile.js'
+import { generateKeypair } from '../src/auth.js'
+import { createResponse } from '../src/webfinger.js'
+import { createNote, wrapCreate } from '../src/outbox.js'
+
+describe('Mastodon Actor Compatibility', () => {
+  test('actor has all required fields for Mastodon', () => {
+    const { publicKey } = generateKeypair()
+
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      name: 'Alice',
+      summary: '<p>Hello!</p>',
+      publicKey
+    })
+
+    // Required by Mastodon
+    assert.ok(actor['@context'], 'missing @context')
+    assert.ok(actor.id, 'missing id')
+    assert.ok(actor.type, 'missing type')
+    assert.ok(actor.preferredUsername, 'missing preferredUsername')
+    assert.ok(actor.inbox, 'missing inbox')
+    assert.ok(actor.outbox, 'missing outbox')
+    assert.ok(actor.publicKey, 'missing publicKey')
+    assert.ok(actor.publicKey.id, 'missing publicKey.id')
+    assert.ok(actor.publicKey.owner, 'missing publicKey.owner')
+    assert.ok(actor.publicKey.publicKeyPem, 'missing publicKeyPem')
+  })
+
+  test('actor @context includes security namespace', () => {
+    const { publicKey } = generateKeypair()
+
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      publicKey
+    })
+
+    assert.ok(
+      actor['@context'].includes('https://w3id.org/security/v1'),
+      '@context must include security namespace for publicKey'
+    )
+  })
+
+  test('publicKey.id follows Mastodon convention', () => {
+    const { publicKey } = generateKeypair()
+
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      publicKey
+    })
+
+    // Mastodon expects keyId to be actor#main-key
+    assert.strictEqual(
+      actor.publicKey.id,
+      'https://example.com/users/alice#main-key'
+    )
+  })
+
+  test('publicKey.owner matches actor id', () => {
+    const { publicKey } = generateKeypair()
+
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      publicKey
+    })
+
+    assert.strictEqual(actor.publicKey.owner, actor.id)
+  })
+
+  test('inbox/outbox URLs follow convention', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice'
+    })
+
+    assert.strictEqual(actor.inbox, 'https://example.com/users/alice/inbox')
+    assert.strictEqual(actor.outbox, 'https://example.com/users/alice/outbox')
+  })
+})
+
+describe('Mastodon WebFinger Compatibility', () => {
+  test('webfinger response has required fields', () => {
+    const response = createResponse(
+      'alice@example.com',
+      'https://example.com/users/alice'
+    )
+
+    assert.ok(response.subject, 'missing subject')
+    assert.ok(response.links, 'missing links')
+    assert.ok(Array.isArray(response.links), 'links must be array')
+  })
+
+  test('webfinger subject uses acct: scheme', () => {
+    const response = createResponse(
+      'alice@example.com',
+      'https://example.com/users/alice'
+    )
+
+    assert.ok(
+      response.subject.startsWith('acct:'),
+      'subject must use acct: scheme'
+    )
+  })
+
+  test('webfinger has self link with ActivityPub type', () => {
+    const response = createResponse(
+      'alice@example.com',
+      'https://example.com/users/alice'
+    )
+
+    const selfLink = response.links.find(l => l.rel === 'self')
+
+    assert.ok(selfLink, 'missing self link')
+    assert.strictEqual(selfLink.type, 'application/activity+json')
+    assert.strictEqual(selfLink.href, 'https://example.com/users/alice')
+  })
+})
+
+describe('Mastodon Note Compatibility', () => {
+  test('note has required fields', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Hello, Mastodon!</p>'
+    })
+
+    assert.strictEqual(note.type, 'Note')
+    assert.ok(note.id, 'missing id')
+    assert.ok(note.attributedTo, 'missing attributedTo')
+    assert.ok(note.content, 'missing content')
+    assert.ok(note.published, 'missing published')
+    assert.ok(note.to, 'missing to')
+    assert.ok(note.cc, 'missing cc')
+  })
+
+  test('public note addresses Public collection', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Public post</p>',
+      public: true
+    })
+
+    assert.ok(
+      note.to.includes('https://www.w3.org/ns/activitystreams#Public'),
+      'public note must address Public collection'
+    )
+  })
+
+  test('note cc includes followers collection', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Public post</p>',
+      public: true
+    })
+
+    assert.ok(
+      note.cc.some(c => c.includes('/followers')),
+      'note cc should include followers collection'
+    )
+  })
+
+  test('published is ISO 8601 format', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Test</p>'
+    })
+
+    // Should be parseable as date
+    const date = new Date(note.published)
+    assert.ok(!isNaN(date.getTime()), 'published must be valid ISO 8601')
+  })
+})
+
+describe('Mastodon Create Activity Compatibility', () => {
+  test('Create activity wraps note correctly', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Hello!</p>'
+    })
+
+    const activity = wrapCreate('https://example.com/users/alice', note)
+
+    assert.strictEqual(activity.type, 'Create')
+    assert.strictEqual(activity.actor, 'https://example.com/users/alice')
+    assert.strictEqual(activity.object, note)
+    assert.ok(activity['@context'], 'missing @context')
+    assert.ok(activity.id, 'missing id')
+    assert.ok(activity.published, 'missing published')
+  })
+
+  test('Create activity copies addressing from object', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Hello!</p>',
+      public: true
+    })
+
+    const activity = wrapCreate('https://example.com/users/alice', note)
+
+    assert.deepStrictEqual(activity.to, note.to)
+    assert.deepStrictEqual(activity.cc, note.cc)
+  })
+})
+
+describe('Fetch Remote Mastodon Actor', async () => {
+  test('can parse real Mastodon actor format', async () => {
+    // Test against mastodon.social's format expectations
+    // This is what a Mastodon actor looks like
+    const mastodonActor = {
+      '@context': [
+        'https://www.w3.org/ns/activitystreams',
+        'https://w3id.org/security/v1'
+      ],
+      id: 'https://mastodon.social/users/test',
+      type: 'Person',
+      preferredUsername: 'test',
+      inbox: 'https://mastodon.social/users/test/inbox',
+      outbox: 'https://mastodon.social/users/test/outbox',
+      publicKey: {
+        id: 'https://mastodon.social/users/test#main-key',
+        owner: 'https://mastodon.social/users/test',
+        publicKeyPem: '-----BEGIN PUBLIC KEY-----\nMIIB...\n-----END PUBLIC KEY-----'
+      }
+    }
+
+    // Our code should be able to work with this format
+    assert.ok(mastodonActor.id)
+    assert.ok(mastodonActor.inbox)
+    assert.ok(mastodonActor.publicKey.publicKeyPem)
+  })
+})

package/test/outbox.test.js

@@ -0,0 +1,195 @@
+/**
+ * Microfed Outbox Module Tests
+ * Run: node --test test/outbox.test.js
+ */
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { createActivity, createNote, wrapCreate, createFollow, createUndo, createAccept } from '../src/outbox.js'
+
+describe('createActivity', () => {
+  test('creates activity with required fields', () => {
+    const activity = createActivity({
+      type: 'Follow',
+      actor: 'https://example.com/users/alice',
+      object: 'https://example.com/users/bob'
+    })
+
+    assert.strictEqual(activity['@context'], 'https://www.w3.org/ns/activitystreams')
+    assert.strictEqual(activity.type, 'Follow')
+    assert.strictEqual(activity.actor, 'https://example.com/users/alice')
+    assert.strictEqual(activity.object, 'https://example.com/users/bob')
+    assert.ok(activity.id)
+    assert.ok(activity.published)
+  })
+
+  test('includes to and cc arrays', () => {
+    const activity = createActivity({
+      type: 'Create',
+      actor: 'https://example.com/users/alice',
+      object: { type: 'Note' },
+      to: ['https://www.w3.org/ns/activitystreams#Public'],
+      cc: ['https://example.com/users/alice/followers']
+    })
+
+    assert.deepStrictEqual(activity.to, ['https://www.w3.org/ns/activitystreams#Public'])
+    assert.deepStrictEqual(activity.cc, ['https://example.com/users/alice/followers'])
+  })
+
+  test('uses provided id', () => {
+    const activity = createActivity({
+      type: 'Like',
+      actor: 'https://example.com/users/alice',
+      object: 'https://example.com/notes/123',
+      id: 'https://example.com/activities/custom-id'
+    })
+
+    assert.strictEqual(activity.id, 'https://example.com/activities/custom-id')
+  })
+
+  test('throws when type is missing', () => {
+    assert.throws(() => {
+      createActivity({
+        actor: 'https://example.com/users/alice',
+        object: 'https://example.com/users/bob'
+      })
+    }, /type is required/)
+  })
+
+  test('throws when actor is missing', () => {
+    assert.throws(() => {
+      createActivity({
+        type: 'Follow',
+        object: 'https://example.com/users/bob'
+      })
+    }, /actor is required/)
+  })
+
+  test('throws when object is missing', () => {
+    assert.throws(() => {
+      createActivity({
+        type: 'Follow',
+        actor: 'https://example.com/users/alice'
+      })
+    }, /object is required/)
+  })
+})
+
+describe('createNote', () => {
+  test('creates note with required fields', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Hello, world!</p>'
+    })
+
+    assert.strictEqual(note.type, 'Note')
+    assert.strictEqual(note.attributedTo, 'https://example.com/users/alice')
+    assert.strictEqual(note.content, '<p>Hello, world!</p>')
+    assert.ok(note.id)
+    assert.ok(note.published)
+  })
+
+  test('public note has correct addressing', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Public post</p>',
+      public: true
+    })
+
+    assert.ok(note.to.includes('https://www.w3.org/ns/activitystreams#Public'))
+    assert.ok(note.cc.includes('https://example.com/users/alice/followers'))
+  })
+
+  test('private note has empty addressing', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>Private post</p>',
+      public: false
+    })
+
+    assert.deepStrictEqual(note.to, [])
+    assert.deepStrictEqual(note.cc, [])
+  })
+
+  test('includes inReplyTo when provided', () => {
+    const note = createNote({
+      actor: 'https://example.com/users/alice',
+      content: '<p>This is a reply</p>',
+      inReplyTo: 'https://other.example/notes/456'
+    })
+
+    assert.strictEqual(note.inReplyTo, 'https://other.example/notes/456')
+  })
+})
+
+describe('wrapCreate', () => {
+  test('wraps note in Create activity', () => {
+    const note = {
+      type: 'Note',
+      id: 'https://example.com/notes/123',
+      content: '<p>Hello</p>',
+      to: ['https://www.w3.org/ns/activitystreams#Public'],
+      cc: ['https://example.com/users/alice/followers']
+    }
+
+    const activity = wrapCreate('https://example.com/users/alice', note)
+
+    assert.strictEqual(activity.type, 'Create')
+    assert.strictEqual(activity.actor, 'https://example.com/users/alice')
+    assert.strictEqual(activity.object, note)
+    assert.deepStrictEqual(activity.to, note.to)
+    assert.deepStrictEqual(activity.cc, note.cc)
+  })
+})
+
+describe('createFollow', () => {
+  test('creates Follow activity', () => {
+    const follow = createFollow(
+      'https://example.com/users/alice',
+      'https://other.example/users/bob'
+    )
+
+    assert.strictEqual(follow.type, 'Follow')
+    assert.strictEqual(follow.actor, 'https://example.com/users/alice')
+    assert.strictEqual(follow.object, 'https://other.example/users/bob')
+    assert.deepStrictEqual(follow.to, ['https://other.example/users/bob'])
+  })
+})
+
+describe('createUndo', () => {
+  test('creates Undo activity for Follow', () => {
+    const follow = {
+      type: 'Follow',
+      id: 'https://example.com/activities/123',
+      actor: 'https://example.com/users/alice',
+      object: 'https://other.example/users/bob',
+      to: ['https://other.example/users/bob'],
+      cc: []
+    }
+
+    const undo = createUndo('https://example.com/users/alice', follow)
+
+    assert.strictEqual(undo.type, 'Undo')
+    assert.strictEqual(undo.actor, 'https://example.com/users/alice')
+    assert.strictEqual(undo.object, follow)
+    assert.deepStrictEqual(undo.to, follow.to)
+  })
+})
+
+describe('createAccept', () => {
+  test('creates Accept activity for Follow', () => {
+    const follow = {
+      type: 'Follow',
+      id: 'https://other.example/activities/456',
+      actor: 'https://other.example/users/bob',
+      object: 'https://example.com/users/alice'
+    }
+
+    const accept = createAccept('https://example.com/users/alice', follow)
+
+    assert.strictEqual(accept.type, 'Accept')
+    assert.strictEqual(accept.actor, 'https://example.com/users/alice')
+    assert.strictEqual(accept.object, follow)
+    assert.deepStrictEqual(accept.to, ['https://other.example/users/bob'])
+  })
+})