fedbox 0.0.4 → 0.0.5

package/lib/server.js

@@ -383,7 +383,7 @@ async function handleRequest(req, res) {
       version: '2.1',
       software: {
         name: 'fedbox',
-        version: '0.0.4',
+        version: '0.0.5',
         repository: 'https://github.com/micro-fed/fedbox'
       },
       protocols: ['activitypub'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fedbox",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Zero to Fediverse in 60 seconds",
   "type": "module",
   "main": "lib/server.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "start": "node lib/server.js",
-    "test": "node --test test/"
+    "test": "node --test 'test/*.test.js'"
   },
   "dependencies": {
     "microfed": "^0.0.13",

package/test/actions.test.js

@@ -0,0 +1,78 @@
+/**
+ * Actions tests
+ */
+
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert'
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from 'fs'
+import { generateKeypair } from 'microfed/auth'
+
+function setupConfig(domain = null) {
+  const { publicKey, privateKey } = generateKeypair()
+  const config = {
+    username: 'alice',
+    displayName: 'Alice',
+    summary: 'Test user',
+    port: 3000,
+    publicKey,
+    privateKey
+  }
+  if (domain) config.domain = domain
+  writeFileSync('fedbox.json', JSON.stringify(config, null, 2))
+}
+
+function cleanup() {
+  if (existsSync('fedbox.json')) unlinkSync('fedbox.json')
+  if (existsSync('data/fedbox.db')) unlinkSync('data/fedbox.db')
+  try { rmSync('data', { recursive: true }) } catch {}
+}
+
+describe('Actions', () => {
+  before(() => {
+    cleanup()
+    if (!existsSync('data')) mkdirSync('data')
+    setupConfig()
+  })
+
+  after(() => {
+    cleanup()
+  })
+
+  test('post creates note with Solid-compatible noteId', async () => {
+    const { post } = await import('../lib/actions.js')
+    const result = await post('Hello world!')
+
+    // noteId should be /alice/posts/xxx (not /alice#me/posts/xxx)
+    assert.ok(result.noteId.includes('/alice/posts/'), 'noteId should include /alice/posts/')
+    assert.ok(!result.noteId.includes('#me/posts'), 'noteId should not have #me before /posts')
+    assert.ok(!result.noteId.includes('#me'), 'noteId should not contain #me at all')
+  })
+
+  test('post returns delivery results', async () => {
+    const { post } = await import('../lib/actions.js')
+    const result = await post('Test delivery')
+
+    assert.ok('delivered' in result, 'result should have delivered stats')
+    assert.ok('success' in result.delivered)
+    assert.ok('failed' in result.delivered)
+  })
+
+  test('myPosts returns saved posts', async () => {
+    const { myPosts } = await import('../lib/actions.js')
+    const posts = myPosts(10)
+    // Should have posts from previous tests
+    assert.ok(posts.length >= 1, 'should have at least 1 post')
+    assert.ok(posts[0].content, 'post should have content')
+    assert.ok(posts[0].id, 'post should have id')
+  })
+
+  test('myPosts posts have Solid-compatible URLs', async () => {
+    const { myPosts } = await import('../lib/actions.js')
+    const posts = myPosts(10)
+
+    for (const post of posts) {
+      assert.ok(post.id.includes('/alice/posts/'), 'post id should include /alice/posts/')
+      assert.ok(!post.id.includes('#me'), 'post id should not contain #me')
+    }
+  })
+})

package/test/store.test.js

@@ -0,0 +1,233 @@
+/**
+ * Store tests
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert'
+import { unlinkSync, existsSync, mkdirSync } from 'fs'
+import {
+  initStore,
+  getStore,
+  addFollower,
+  removeFollower,
+  getFollowers,
+  getFollowerCount,
+  addFollowing,
+  acceptFollowing,
+  getFollowing,
+  getFollowingCount,
+  savePost,
+  getPosts,
+  getPost,
+  cacheActor,
+  getCachedActor,
+  saveActivity,
+  getActivities
+} from '../lib/store.js'
+
+const TEST_DB = 'test/test.db'
+
+function cleanup() {
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB)
+  }
+}
+
+describe('Store', () => {
+  beforeEach(() => {
+    cleanup()
+    if (!existsSync('test')) mkdirSync('test', { recursive: true })
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('initStore creates database', () => {
+    assert.ok(existsSync(TEST_DB))
+  })
+
+  test('getStore returns database instance', () => {
+    const db = getStore()
+    assert.ok(db)
+  })
+})
+
+describe('Followers', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('addFollower and getFollowers', () => {
+    addFollower('https://example.com/user/alice', 'https://example.com/user/alice/inbox')
+    const followers = getFollowers()
+    assert.strictEqual(followers.length, 1)
+    assert.strictEqual(followers[0].actor, 'https://example.com/user/alice')
+    assert.strictEqual(followers[0].inbox, 'https://example.com/user/alice/inbox')
+  })
+
+  test('getFollowerCount', () => {
+    assert.strictEqual(getFollowerCount(), 0)
+    addFollower('https://example.com/user/alice', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 1)
+    addFollower('https://example.com/user/bob', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 2)
+  })
+
+  test('removeFollower', () => {
+    addFollower('https://example.com/user/alice', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 1)
+    removeFollower('https://example.com/user/alice')
+    assert.strictEqual(getFollowerCount(), 0)
+  })
+})
+
+describe('Following', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('addFollowing with pending status', () => {
+    addFollowing('https://example.com/user/bob', false)
+    assert.strictEqual(getFollowingCount(), 0) // Not accepted yet
+  })
+
+  test('acceptFollowing', () => {
+    addFollowing('https://example.com/user/bob', false)
+    assert.strictEqual(getFollowingCount(), 0)
+    acceptFollowing('https://example.com/user/bob')
+    assert.strictEqual(getFollowingCount(), 1)
+  })
+
+  test('getFollowing returns only accepted', () => {
+    addFollowing('https://example.com/user/bob', false)
+    addFollowing('https://example.com/user/charlie', true)
+    const following = getFollowing()
+    assert.strictEqual(following.length, 1)
+    assert.strictEqual(following[0].actor, 'https://example.com/user/charlie')
+  })
+})
+
+describe('Posts', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('savePost and getPost', () => {
+    const id = 'https://example.com/alice/posts/123'
+    savePost(id, 'Hello world!')
+    const post = getPost(id)
+    assert.ok(post)
+    assert.strictEqual(post.id, id)
+    assert.strictEqual(post.content, 'Hello world!')
+  })
+
+  test('savePost with inReplyTo', () => {
+    const id = 'https://example.com/alice/posts/456'
+    const replyTo = 'https://other.com/posts/789'
+    savePost(id, 'This is a reply', replyTo)
+    const post = getPost(id)
+    assert.strictEqual(post.in_reply_to, replyTo)
+  })
+
+  test('getPosts returns posts', () => {
+    savePost('https://example.com/posts/1', 'First')
+    savePost('https://example.com/posts/2', 'Second')
+    savePost('https://example.com/posts/3', 'Third')
+    const posts = getPosts(10)
+    assert.strictEqual(posts.length, 3)
+    // All posts should be present
+    const contents = posts.map(p => p.content)
+    assert.ok(contents.includes('First'))
+    assert.ok(contents.includes('Second'))
+    assert.ok(contents.includes('Third'))
+  })
+
+  test('getPosts respects limit', () => {
+    for (let i = 0; i < 10; i++) {
+      savePost(`https://example.com/posts/${i}`, `Post ${i}`)
+    }
+    const posts = getPosts(5)
+    assert.strictEqual(posts.length, 5)
+  })
+})
+
+describe('Actor Cache', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('cacheActor and getCachedActor', () => {
+    const actor = {
+      id: 'https://example.com/user/alice',
+      type: 'Person',
+      preferredUsername: 'alice'
+    }
+    cacheActor(actor)
+    const cached = getCachedActor(actor.id)
+    assert.deepStrictEqual(cached, actor)
+  })
+
+  test('getCachedActor returns null for unknown', () => {
+    const cached = getCachedActor('https://example.com/unknown')
+    assert.strictEqual(cached, null)
+  })
+})
+
+describe('Activities', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('saveActivity and getActivities', () => {
+    const activity = {
+      id: 'https://example.com/activity/1',
+      type: 'Create',
+      actor: 'https://example.com/user/alice',
+      object: { type: 'Note', content: 'Hello' }
+    }
+    saveActivity(activity)
+    const activities = getActivities(10)
+    assert.strictEqual(activities.length, 1)
+    assert.strictEqual(activities[0].type, 'Create')
+    assert.deepStrictEqual(activities[0].raw, activity)
+  })
+})