holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/test-relay-permanence.js

@@ -1,376 +0,0 @@
-/**
- * Comprehensive Data Permanence Test Through Relays
- *
- * This test validates complete data persistence through the Nostr relay network:
- * 1. Write data from Node 1
- * 2. Verify immediate readback on Node 1
- * 3. Wait for relay propagation
- * 4. Create Node 2 and verify it can read Node 1's data
- * 5. Restart Node 1 (new instance) and verify data recovery
- * 6. Update data and verify updates propagate
- * 7. Verify batch writes persist
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-// Test configuration
-const TEST_CONFIG = {
-  appName: 'relay-permanence-test',
-  relays: RELAYS,
-  logLevel: 'INFO'
-};
-
-const TEST_HOLON = 'global://permanence';
-const WAIT_FOR_SYNC = 4000; // 4 seconds for relay sync
-
-// Colors for console
-const c = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  bold: '\x1b[1m'
-};
-
-function log(msg, color = 'reset') {
-  console.log(`${c[color]}${msg}${c.reset}`);
-}
-
-function section(title) {
-  console.log('\n' + '═'.repeat(70));
-  log(`  ${title}`, 'cyan');
-  console.log('═'.repeat(70) + '\n');
-}
-
-function test(name, passed, details = '') {
-  const icon = passed ? '✅' : '❌';
-  const color = passed ? 'green' : 'red';
-  log(`${icon} ${name}`, color);
-  if (details) console.log(`   ${details}`);
-}
-
-async function wait(ms, message) {
-  if (message) log(`⏳ ${message}`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// Track test results
-const results = {
-  passed: 0,
-  failed: 0,
-  tests: []
-};
-
-function addResult(name, passed, details = '') {
-  test(name, passed, details);
-  results.tests.push({ name, passed, details });
-  if (passed) results.passed++;
-  else results.failed++;
-}
-
-/**
- * Test 1: Write data from Node 1 and verify immediate readback
- */
-async function test1_WriteAndRead(hs) {
-  section('TEST 1: Write Data and Immediate Readback');
-
-  const testData = {
-    id: `perm-test-${Date.now()}`,
-    message: 'Data permanence test',
-    timestamp: Date.now(),
-    metadata: {
-      test: 'write-read',
-      node: 1
-    }
-  };
-
-  log('Writing test data from Node 1...', 'yellow');
-  const writeResult = await hs.write(TEST_HOLON, 'data', testData);
-  addResult('Write operation successful', writeResult, `ID: ${testData.id}`);
-
-  if (!writeResult) {
-    log('⚠️  Write failed - skipping read test', 'red');
-    return { success: false, testData };
-  }
-
-  await wait(500, 'Waiting for local cache...');
-
-  log('Reading data back on Node 1...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  addResult('Data readable immediately after write', found,
-    found ? `Found ${readData.length} record(s)` : 'Data not found');
-
-  if (found) {
-    const record = readData.find(d => d.id === testData.id);
-    const matches = record.message === testData.message;
-    addResult('Data content matches original', matches);
-  }
-
-  return { success: writeResult && found, testData };
-}
-
-/**
- * Test 2: Verify data persists after relay sync period
- */
-async function test2_RelayPersistence(hs, testData) {
-  section('TEST 2: Data Persistence After Relay Sync');
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for relay synchronization...`);
-
-  log('Re-reading data after sync period...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  addResult('Data persists after relay sync', found,
-    found ? `Found ${readData.length} record(s)` : 'Data disappeared');
-
-  return { success: found };
-}
-
-/**
- * Test 3: Create second node and verify cross-node data visibility
- */
-async function test3_CrossNodeSync(testData, privateKey) {
-  section('TEST 3: Cross-Node Data Synchronization');
-
-  log('Creating Node 2 with same private key...', 'yellow');
-  const hs2 = new HoloSphere({
-    ...TEST_CONFIG,
-    privateKey // Same key to see same events
-  });
-
-  log(`Node 2 Public Key: ${hs2.client.publicKey}`, 'blue');
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for Node 2 relay connection...`);
-
-  log('Node 2 reading data from relays...', 'yellow');
-  const readData = await hs2.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  addResult('Node 2 can read Node 1 data', found,
-    found ? `Found ${readData.length} record(s)` : 'Data not visible on Node 2');
-
-  if (found) {
-    const record = readData.find(d => d.id === testData.id);
-    const matches = record.message === testData.message;
-    addResult('Data content matches on Node 2', matches);
-  }
-
-  return { success: found, hs2 };
-}
-
-/**
- * Test 4: Restart Node 1 and verify data recovery from relays
- */
-async function test4_NodeRestart(testData, privateKey) {
-  section('TEST 4: Data Recovery After Node Restart');
-
-  log('Simulating Node 1 restart (new instance with same key)...', 'yellow');
-  const hsRestart = new HoloSphere({
-    ...TEST_CONFIG,
-    privateKey // Same key
-  });
-
-  log(`Restarted Node Public Key: ${hsRestart.client.publicKey}`, 'blue');
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for relay connection...`);
-
-  log('Restarted node reading from relays...', 'yellow');
-  const readData = await hsRestart.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  addResult('Data recovered after restart', found,
-    found ? `Found ${readData.length} record(s)` : 'Data not recovered');
-
-  return { success: found, hsRestart };
-}
-
-/**
- * Test 5: Update data and verify update persistence
- */
-async function test5_UpdatePersistence(hs, testData) {
-  section('TEST 5: Data Update and Update Persistence');
-
-  const updatedData = {
-    ...testData,
-    message: 'Updated message - testing permanence',
-    metadata: {
-      ...testData.metadata,
-      updated: true,
-      updateTimestamp: Date.now()
-    }
-  };
-
-  log('Updating data...', 'yellow');
-  const writeResult = await hs.write(TEST_HOLON, 'data', updatedData);
-  addResult('Update write successful', writeResult);
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for update propagation...`);
-
-  log('Reading updated data...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.find(d => d.id === testData.id);
-  const updatePersisted = found && found.metadata && found.metadata.updated === true;
-
-  addResult('Update persisted correctly', updatePersisted,
-    updatePersisted ? `Message: "${found.message}"` : 'Update not found');
-
-  return { success: writeResult && updatePersisted };
-}
-
-/**
- * Test 6: Verify update visible on second node
- */
-async function test6_UpdateCrossNode(hs2, testData) {
-  section('TEST 6: Update Visibility Across Nodes');
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for update to sync to Node 2...`);
-
-  log('Node 2 reading updated data...', 'yellow');
-  const readData = await hs2.read(TEST_HOLON, 'data');
-
-  const found = readData && readData.find(d => d.id === testData.id);
-  const updateVisible = found && found.metadata && found.metadata.updated === true;
-
-  addResult('Update visible on Node 2', updateVisible,
-    updateVisible ? `Message: "${found.message}"` : 'Update not visible');
-
-  return { success: updateVisible };
-}
-
-/**
- * Test 7: Multiple writes and verify all persist
- */
-async function test7_BatchPersistence(hs) {
-  section('TEST 7: Batch Write Persistence');
-
-  const count = 5;
-  const records = [];
-
-  log(`Writing ${count} records...`, 'yellow');
-  for (let i = 0; i < count; i++) {
-    const record = {
-      id: `batch-${Date.now()}-${i}`,
-      index: i,
-      timestamp: Date.now(),
-      message: `Batch record ${i + 1}/${count}`
-    };
-    records.push(record);
-    const result = await hs.write(TEST_HOLON, 'data', record);
-    if (result) {
-      log(`  ✓ Written: ${record.id}`, 'blue');
-    } else {
-      log(`  ✗ Failed: ${record.id}`, 'red');
-    }
-  }
-
-  await wait(WAIT_FOR_SYNC, `Waiting ${WAIT_FOR_SYNC/1000}s for batch sync...`);
-
-  log('Reading all records...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'data');
-
-  const foundCount = records.filter(r =>
-    readData && readData.some(d => d.id === r.id)
-  ).length;
-
-  const allFound = foundCount === count;
-  addResult('All batch records persisted', allFound,
-    `Found ${foundCount}/${count} records`);
-
-  return { success: allFound, records };
-}
-
-/**
- * Main test runner
- */
-async function runTests() {
-  log('\n╔═══════════════════════════════════════════════════════════════════╗', 'cyan');
-  log('║     HOLOSPHERE DATA PERMANENCE TEST - NOSTR RELAY NETWORK         ║', 'cyan');
-  log('╚═══════════════════════════════════════════════════════════════════╝', 'cyan');
-
-  log(`\nTest Configuration:`, 'yellow');
-  log(`  App Name: ${TEST_CONFIG.appName}`, 'blue');
-  log(`  Test Holon: ${TEST_HOLON}`, 'blue');
-  log(`  Relays:`, 'blue');
-  TEST_CONFIG.relays.forEach(relay => log(`    • ${relay}`, 'blue'));
-  log(`  Sync Wait Time: ${WAIT_FOR_SYNC / 1000}s`, 'blue');
-
-  try {
-    // Initialize Node 1
-    log('\n📡 Initializing Node 1...', 'yellow');
-    const hs1 = new HoloSphere(TEST_CONFIG);
-    const privateKey = hs1.client.privateKey;
-    log(`Node 1 Public Key: ${hs1.client.publicKey}`, 'blue');
-
-    await wait(2000, 'Waiting for initial relay connections...');
-
-    // Run all tests
-    const { success: t1, testData } = await test1_WriteAndRead(hs1);
-    if (!t1) {
-      log('\n⚠️  Initial write failed - cannot continue tests', 'red');
-      throw new Error('Initial write failed');
-    }
-
-    const { success: t2 } = await test2_RelayPersistence(hs1, testData);
-    const { success: t3, hs2 } = await test3_CrossNodeSync(testData, privateKey);
-    const { success: t4 } = await test4_NodeRestart(testData, privateKey);
-    const { success: t5 } = await test5_UpdatePersistence(hs1, testData);
-    const { success: t6 } = await test6_UpdateCrossNode(hs2, testData);
-    const { success: t7 } = await test7_BatchPersistence(hs1);
-
-  } catch (error) {
-    log('\n❌ TEST SUITE FAILED WITH ERROR:', 'red');
-    console.error(error);
-    results.failed++;
-  }
-
-  // Print summary
-  section('TEST SUMMARY');
-
-  results.tests.forEach(t => {
-    test(t.name, t.passed, t.details);
-  });
-
-  console.log('\n' + '─'.repeat(70));
-  log(`Total Tests: ${results.tests.length}`, 'blue');
-  log(`Passed: ${results.passed}`, 'green');
-  log(`Failed: ${results.failed}`, 'red');
-  const successRate = ((results.passed / results.tests.length) * 100).toFixed(1);
-  log(`Success Rate: ${successRate}%`, results.failed === 0 ? 'green' : 'yellow');
-  console.log('─'.repeat(70) + '\n');
-
-  if (results.failed === 0) {
-    log('🎉 ALL TESTS PASSED!', 'green');
-    log('✓ Data writes to relays successfully', 'green');
-    log('✓ Data persists across time', 'green');
-    log('✓ Data syncs across multiple nodes', 'green');
-    log('✓ Data survives node restarts', 'green');
-    log('✓ Updates propagate correctly', 'green');
-    log('✓ Batch operations work reliably', 'green');
-    log('\n🌐 Your data is PERMANENT on the Nostr relay network!', 'bold');
-  } else {
-    log('⚠️  SOME TESTS FAILED', 'yellow');
-    log('Please review the results above.', 'yellow');
-  }
-
-  log('\nTest complete.\n');
-
-  setTimeout(() => process.exit(results.failed === 0 ? 0 : 1), 1000);
-}
-
-// Run the test suite
-runTests().catch(error => {
-  console.error('❌ Fatal error:', error);
-  process.exit(1);
-});

package/tests/unit/test-second-node.js

@@ -1,95 +0,0 @@
-/**
- * Test Second Node - Verify quest synchronization
- *
- * This script simulates a second node connecting to the same relays
- * and verifying it can see quests created by the first node.
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-console.log('\n=== Second Node Test ===\n');
-console.log('This node will connect to the same relays and fetch quests...\n');
-
-// Initialize with the SAME configuration as the first node
-const hs = new HoloSphere({
-  appName: 'quest-game',  // MUST match the first node's appName
-  relays: RELAYS,
-  logLevel: 'INFO'
-});
-
-console.log('Second Node initialized with relays:', hs.config.relays);
-console.log('Second Node Public Key:', hs.client.publicKey);
-console.log('(Note: Different public key is OK - we can still read public quests)\n');
-
-// Use the same holon ID as the first node
-const QUEST_HOLON = 'global://quests';
-
-async function testSync() {
-  // Wait for relay connections to establish
-  console.log('⏳ Waiting 3 seconds for relay connections...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  console.log('\n📋 Fetching quests from relays...');
-
-  const quests = await hs.read(QUEST_HOLON, 'quests');
-
-  if (quests && quests.length > 0) {
-    console.log(`\n✅ SUCCESS! Found ${quests.length} quest(s) from the first node:\n`);
-    quests.forEach((quest, index) => {
-      console.log(`${index + 1}. ${quest.title}`);
-      console.log(`   ID: ${quest.id}`);
-      console.log(`   Status: ${quest.status || 'active'}`);
-      console.log(`   Description: ${quest.description || 'No description'}`);
-      console.log(`   Reward: ${quest.reward || 0} gold`);
-      console.log('');
-    });
-
-    console.log('✅ QUEST SYNCHRONIZATION IS WORKING!');
-    console.log('   Quests created on Node 1 are visible on Node 2.\n');
-  } else {
-    console.log('\n❌ No quests found.');
-    console.log('   Possible reasons:');
-    console.log('   1. First node hasn\'t created quests yet');
-    console.log('   2. Quests haven\'t synced to relays yet (try again in a few seconds)');
-    console.log('   3. Different appName between nodes');
-    console.log('   4. Relay connectivity issues\n');
-  }
-
-  // Test creating a quest from this node
-  console.log('📝 Creating a quest from the second node...\n');
-
-  const newQuest = {
-    id: `quest-${Date.now()}-from-node2`,
-    title: 'Explore the Mysterious Cave',
-    description: 'Discover what lies deep within the cave',
-    reward: 750,
-    difficulty: 'medium'
-  };
-
-  const result = await hs.write(QUEST_HOLON, 'quests', newQuest);
-
-  if (result) {
-    console.log('✅ Quest created from Node 2!');
-    console.log('   The first node should now see 3 quests total.\n');
-  } else {
-    console.log('❌ Failed to create quest from Node 2\n');
-  }
-
-  // Fetch again to see all quests
-  await new Promise(resolve => setTimeout(resolve, 2000));
-  const allQuests = await hs.read(QUEST_HOLON, 'quests');
-  console.log(`📋 Total quests after Node 2 creation: ${allQuests ? allQuests.length : 0}\n`);
-
-  console.log('Test complete! Press Ctrl+C to exit.');
-}
-
-testSync().catch(error => {
-  console.error('❌ Test failed:', error);
-  process.exit(1);
-});

package/tests/unit/test-simple-write.js

@@ -1,89 +0,0 @@
-/**
- * Simple write test to debug relay issues
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-console.log('\n=== SIMPLE WRITE TEST ===\n');
-
-const hs = new HoloSphere({
-  appName: 'simple-test',
-  relays: RELAYS,
-  logLevel: 'DEBUG'
-});
-
-console.log(`Public Key: ${hs.client.publicKey}`);
-console.log(`Relays:`, hs.config.relays);
-
-// Wait for connections
-await new Promise(resolve => setTimeout(resolve, 3000));
-
-console.log('\n--- Writing data ---\n');
-
-const testData = {
-  id: 'test-123',
-  message: 'Hello, relay!',
-  timestamp: Date.now()
-};
-
-try {
-  // Get more details from the write
-  const storage = await import('./src/storage/nostr-wrapper.js');
-  const nostrAsync = await import('./src/storage/nostr-async.js');
-
-  const path = storage.buildPath('simple-test', 'global://test', 'data', testData.id);
-  console.log(`Path: ${path}`);
-
-  // Call nostrPut directly to see the result
-  const result = await nostrAsync.nostrPut(hs.client, path, testData);
-
-  console.log('\n--- Publish Result ---');
-  console.log(`Event ID: ${result.event.id}`);
-  console.log(`Event created_at: ${result.event.created_at}`);
-  console.log(`Event pubkey: ${result.event.pubkey}`);
-  console.log(`Event tags:`, JSON.stringify(result.event.tags, null, 2));
-  console.log(`\nRelay Results:`);
-
-  result.results.forEach((r, i) => {
-    console.log(`\n  Relay ${i + 1}: ${hs.config.relays[i]}`);
-    console.log(`    Status: ${r.status}`);
-    if (r.status === 'fulfilled') {
-      console.log(`    Value: ${r.value}`);
-    } else if (r.status === 'rejected') {
-      console.log(`    Reason: ${r.reason}`);
-    }
-  });
-
-  const success = result.results.some(r => r.status === 'fulfilled');
-  console.log(`\n--- Summary ---`);
-  console.log(`Success: ${success}`);
-  console.log(`Fulfilled: ${result.results.filter(r => r.status === 'fulfilled').length}/${result.results.length}`);
-
-  // Now try reading it back
-  console.log('\n--- Reading data back ---\n');
-  await new Promise(resolve => setTimeout(resolve, 2000));
-
-  const readData = await hs.read('global://test', 'data');
-  console.log(`Found ${readData ? readData.length : 0} records`);
-
-  if (readData && readData.length > 0) {
-    readData.forEach((d, i) => {
-      console.log(`\nRecord ${i + 1}:`);
-      console.log(JSON.stringify(d, null, 2));
-    });
-  }
-
-} catch (error) {
-  console.error('\n❌ Error:', error);
-  console.error(error.stack);
-}
-
-console.log('\n=== TEST COMPLETE ===\n');
-
-setTimeout(() => process.exit(0), 1000);