microfed 0.0.12 → 0.0.13

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'])
+  })
+})

package/test/profile.test.js

@@ -0,0 +1,213 @@
+/**
+ * Microfed Profile Module Tests
+ * Run: node --test test/profile.test.js
+ */
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { createActor, createMinimalActor, parseActor, getActorId, buildActorUrl } from '../src/profile.js'
+
+describe('createActor', () => {
+  test('creates actor with required fields', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice'
+    })
+
+    assert.strictEqual(actor.id, 'https://example.com/users/alice')
+    assert.strictEqual(actor.type, 'Person')
+    assert.strictEqual(actor.preferredUsername, 'alice')
+    assert.strictEqual(actor.inbox, 'https://example.com/users/alice/inbox')
+    assert.strictEqual(actor.outbox, 'https://example.com/users/alice/outbox')
+    assert.strictEqual(actor.followers, 'https://example.com/users/alice/followers')
+    assert.strictEqual(actor.following, 'https://example.com/users/alice/following')
+  })
+
+  test('includes @context with ActivityStreams and security', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice'
+    })
+
+    assert.ok(Array.isArray(actor['@context']))
+    assert.ok(actor['@context'].includes('https://www.w3.org/ns/activitystreams'))
+    assert.ok(actor['@context'].includes('https://w3id.org/security/v1'))
+  })
+
+  test('supports different actor types', () => {
+    const service = createActor({
+      id: 'https://example.com/bot',
+      username: 'bot',
+      type: 'Service'
+    })
+
+    assert.strictEqual(service.type, 'Service')
+  })
+
+  test('includes optional fields when provided', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      name: 'Alice',
+      summary: '<p>Hello!</p>',
+      url: 'https://example.com/@alice'
+    })
+
+    assert.strictEqual(actor.name, 'Alice')
+    assert.strictEqual(actor.summary, '<p>Hello!</p>')
+    assert.strictEqual(actor.url, 'https://example.com/@alice')
+  })
+
+  test('formats icon as Image object', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      icon: 'https://example.com/avatar.png'
+    })
+
+    assert.deepStrictEqual(actor.icon, {
+      type: 'Image',
+      url: 'https://example.com/avatar.png'
+    })
+  })
+
+  test('includes publicKey when provided', () => {
+    const publicKey = '-----BEGIN PUBLIC KEY-----\nMIIB...\n-----END PUBLIC KEY-----'
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      publicKey
+    })
+
+    assert.strictEqual(actor.publicKey.id, 'https://example.com/users/alice#main-key')
+    assert.strictEqual(actor.publicKey.owner, 'https://example.com/users/alice')
+    assert.strictEqual(actor.publicKey.publicKeyPem, publicKey)
+  })
+
+  test('includes sharedInbox endpoint when provided', () => {
+    const actor = createActor({
+      id: 'https://example.com/users/alice',
+      username: 'alice',
+      sharedInbox: 'https://example.com/inbox'
+    })
+
+    assert.deepStrictEqual(actor.endpoints, {
+      sharedInbox: 'https://example.com/inbox'
+    })
+  })
+
+  test('throws when id is missing', () => {
+    assert.throws(() => {
+      createActor({ username: 'alice' })
+    }, /id is required/)
+  })
+
+  test('throws when username is missing', () => {
+    assert.throws(() => {
+      createActor({ id: 'https://example.com/users/alice' })
+    }, /username is required/)
+  })
+})
+
+describe('createMinimalActor', () => {
+  test('creates actor with just id and username', () => {
+    const actor = createMinimalActor(
+      'https://example.com/users/bob',
+      'bob'
+    )
+
+    assert.strictEqual(actor.id, 'https://example.com/users/bob')
+    assert.strictEqual(actor.preferredUsername, 'bob')
+    assert.strictEqual(actor.type, 'Person')
+  })
+})
+
+describe('parseActor', () => {
+  test('parses actor object', () => {
+    const input = {
+      id: 'https://example.com/users/alice',
+      inbox: 'https://example.com/users/alice/inbox'
+    }
+
+    const actor = parseActor(input)
+    assert.strictEqual(actor.id, input.id)
+  })
+
+  test('parses JSON string', () => {
+    const json = '{"id":"https://example.com/users/alice","inbox":"https://example.com/users/alice/inbox"}'
+
+    const actor = parseActor(json)
+    assert.strictEqual(actor.id, 'https://example.com/users/alice')
+  })
+
+  test('throws when id is missing', () => {
+    assert.throws(() => {
+      parseActor({ inbox: 'https://example.com/inbox' })
+    }, /missing id/)
+  })
+
+  test('throws when inbox is missing', () => {
+    assert.throws(() => {
+      parseActor({ id: 'https://example.com/users/alice' })
+    }, /missing inbox/)
+  })
+})
+
+describe('getActorId', () => {
+  test('returns string as-is', () => {
+    assert.strictEqual(
+      getActorId('https://example.com/users/alice'),
+      'https://example.com/users/alice'
+    )
+  })
+
+  test('extracts id from object', () => {
+    assert.strictEqual(
+      getActorId({ id: 'https://example.com/users/alice' }),
+      'https://example.com/users/alice'
+    )
+  })
+
+  test('extracts actor from activity', () => {
+    assert.strictEqual(
+      getActorId({ actor: 'https://example.com/users/alice' }),
+      'https://example.com/users/alice'
+    )
+  })
+
+  test('handles nested actor object', () => {
+    assert.strictEqual(
+      getActorId({ actor: { id: 'https://example.com/users/alice' } }),
+      'https://example.com/users/alice'
+    )
+  })
+
+  test('throws when cannot extract id', () => {
+    assert.throws(() => {
+      getActorId({})
+    }, /Cannot extract actor ID/)
+  })
+})
+
+describe('buildActorUrl', () => {
+  test('builds URL with default path', () => {
+    assert.strictEqual(
+      buildActorUrl('example.com', 'alice'),
+      'https://example.com/users/alice'
+    )
+  })
+
+  test('builds URL with custom path', () => {
+    assert.strictEqual(
+      buildActorUrl('example.com', 'alice', '/@{username}'),
+      'https://example.com/@alice'
+    )
+  })
+
+  test('handles subdomain', () => {
+    assert.strictEqual(
+      buildActorUrl('social.example.org', 'bob'),
+      'https://social.example.org/users/bob'
+    )
+  })
+})