local-memory-mcp 1.0.2

package/test/test-npm-package.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+
+/**
+ * Local Memory Server NPM Package - Comprehensive Test Suite
+ * 
+ * This test suite validates the npm package installation, binary downloads,
+ * platform detection, and basic functionality across different scenarios.
+ */
+
+const { spawn, exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+// Test configuration
+const TEST_CONFIG = {
+  timeout: 30000,
+  verbose: process.argv.includes('--verbose') || process.env.VERBOSE === 'true',
+  cleanup: !process.argv.includes('--no-cleanup'),
+  testDir: path.join(os.tmpdir(), `local-memory-npm-test-${Date.now()}`)
+};
+
+/**
+ * Test utilities
+ */
+class TestRunner {
+  constructor() {
+    this.tests = [];
+    this.passed = 0;
+    this.failed = 0;
+    this.skipped = 0;
+  }
+  
+  log(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = {
+      info: '📋',
+      success: '✅',
+      error: '❌',
+      warning: '⚠️',
+      debug: '🔍'
+    }[level] || '📋';
+    
+    console.log(`${prefix} ${message}`);
+    
+    if (level === 'debug' && !TEST_CONFIG.verbose) {
+      return; // Skip debug messages unless verbose
+    }
+  }
+  
+  async runCommand(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(command, args, {
+        stdio: TEST_CONFIG.verbose ? 'inherit' : 'pipe',
+        timeout: TEST_CONFIG.timeout,
+        ...options
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      if (!TEST_CONFIG.verbose) {
+        proc.stdout?.on('data', data => stdout += data.toString());
+        proc.stderr?.on('data', data => stderr += data.toString());
+      }
+      
+      proc.on('close', code => resolve({ code, stdout, stderr }));
+      proc.on('error', reject);
+    });
+  }
+  
+  async test(name, testFn, options = {}) {
+    this.log(`Running: ${name}`);
+    
+    try {
+      await testFn();
+      this.passed++;
+      this.log(`PASS: ${name}`, 'success');
+    } catch (error) {
+      this.failed++;
+      this.log(`FAIL: ${name} - ${error.message}`, 'error');
+      if (TEST_CONFIG.verbose) {
+        console.error(error.stack);
+      }
+      
+      if (options.critical) {
+        throw new Error(`Critical test failed: ${name}`);
+      }
+    }
+  }
+  
+  summary() {
+    const total = this.passed + this.failed + this.skipped;
+    this.log(`\nTest Summary: ${this.passed}/${total} passed, ${this.failed} failed, ${this.skipped} skipped`);
+    
+    if (this.failed > 0) {
+      this.log('Some tests failed!', 'error');
+      process.exit(1);
+    } else {
+      this.log('All tests passed!', 'success');
+      process.exit(0);
+    }
+  }
+}
+
+/**
+ * Test functions
+ */
+async function testPackageStructure(runner) {
+  await runner.test('Package structure validation', async () => {
+    const packageDir = path.join(__dirname, '..');
+    
+    // Check required files exist
+    const requiredFiles = [
+      'package.json',
+      'README.md', 
+      'CHANGELOG.md',
+      'index.js',
+      'bin/local-memory',
+      'scripts/install.js',
+      'scripts/test.js',
+      'scripts/uninstall.js'
+    ];
+    
+    for (const file of requiredFiles) {
+      const filePath = path.join(packageDir, file);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Missing required file: ${file}`);
+      }
+    }
+    
+    // Validate package.json
+    const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'));
+    
+    if (packageJson.name !== '@local-memory/server') {
+      throw new Error('Invalid package name');
+    }
+    
+    if (!packageJson.version || !packageJson.version.match(/^\d+\.\d+\.\d+/)) {
+      throw new Error('Invalid package version');
+    }
+    
+    if (!packageJson.bin || !packageJson.bin['local-memory']) {
+      throw new Error('Missing binary configuration');
+    }
+    
+    runner.log('Package structure is valid', 'debug');
+  });
+}
+
+async function testPlatformDetection(runner) {
+  await runner.test('Platform detection', async () => {
+    const { getPlatformInfo } = require('../scripts/install.js');
+    
+    const platformInfo = getPlatformInfo();
+    
+    if (!platformInfo.binaryName) {
+      throw new Error('Platform detection failed - no binary name');
+    }
+    
+    if (!platformInfo.platformPath) {
+      throw new Error('Platform detection failed - no platform path');
+    }
+    
+    // Verify binary name follows expected pattern
+    const validPatterns = [
+      /^local-memory-linux$/,
+      /^local-memory-macos-(arm|intel)$/,
+      /^local-memory-windows\.exe$/
+    ];
+    
+    const isValid = validPatterns.some(pattern => pattern.test(platformInfo.binaryName));
+    if (!isValid) {
+      throw new Error(`Invalid binary name for platform: ${platformInfo.binaryName}`);
+    }
+    
+    runner.log(`Detected platform: ${platformInfo.platform}-${platformInfo.arch} -> ${platformInfo.binaryName}`, 'debug');
+  });
+}
+
+async function testInstallationSimulation(runner) {
+  await runner.test('Installation simulation', async () => {
+    // Create temporary test environment
+    fs.mkdirSync(TEST_CONFIG.testDir, { recursive: true });
+    
+    // Copy package files to test directory
+    const packageDir = path.join(__dirname, '..');
+    const testPackageDir = path.join(TEST_CONFIG.testDir, 'package');
+    
+    // Copy package structure (without binaries for simulation)
+    await runner.runCommand('cp', ['-r', packageDir, testPackageDir]);
+    
+    // Remove any existing binaries to simulate fresh install
+    const binDir = path.join(testPackageDir, 'bin');
+    if (fs.existsSync(binDir)) {
+      fs.rmSync(binDir, { recursive: true, force: true });
+    }
+    
+    // Test that installation script can detect platform
+    const originalCwd = process.cwd();
+    process.chdir(testPackageDir);
+    
+    const installScriptPath = path.join(testPackageDir, 'scripts', 'install.js');
+    delete require.cache[installScriptPath];
+    const { getPlatformInfo } = require(installScriptPath);
+    const platformInfo = getPlatformInfo();
+    
+    if (!platformInfo || !platformInfo.binaryName) {
+      throw new Error('Installation simulation failed - platform detection');
+    }
+    
+    runner.log('Installation simulation passed', 'debug');
+    
+    // Cleanup
+    process.chdir(originalCwd);
+    if (TEST_CONFIG.cleanup) {
+      fs.rmSync(TEST_CONFIG.testDir, { recursive: true, force: true });
+    }
+  });
+}
+
+async function testMainEntryPoint(runner) {
+  await runner.test('Main entry point functionality', async () => {
+    const indexPath = path.join(__dirname, '..', 'index.js');
+    
+    // Test that index.js can be required without errors
+    delete require.cache[require.resolve(indexPath)];
+    const indexModule = require(indexPath);
+    
+    if (typeof indexModule.getBinaryName !== 'function') {
+      throw new Error('Missing getBinaryName function');
+    }
+    
+    if (typeof indexModule.getBinaryPath !== 'function') {
+      throw new Error('Missing getBinaryPath function');
+    }
+    
+    if (typeof indexModule.main !== 'function') {
+      throw new Error('Missing main function');
+    }
+    
+    // Test binary name detection
+    const binaryName = indexModule.getBinaryName();
+    if (!binaryName || typeof binaryName !== 'string') {
+      throw new Error('Invalid binary name detection');
+    }
+    
+    runner.log(`Entry point functions work correctly, binary name: ${binaryName}`, 'debug');
+  });
+}
+
+async function testScriptFunctionality(runner) {
+  await runner.test('Script functionality', async () => {
+    const scriptsDir = path.join(__dirname, '..', 'scripts');
+    
+    // Test that all scripts can be required
+    const scripts = ['install.js', 'test.js', 'uninstall.js'];
+    
+    for (const script of scripts) {
+      const scriptPath = path.join(scriptsDir, script);
+      
+      if (!fs.existsSync(scriptPath)) {
+        throw new Error(`Missing script: ${script}`);
+      }
+      
+      // Check that script is executable
+      const stats = fs.statSync(scriptPath);
+      if (!(stats.mode & 0o111)) {
+        // Not executable - this is okay for scripts, they're run with node
+        runner.log(`Script ${script} is not executable (but will work with node)`, 'debug');
+      }
+      
+      // Test that script can be required (basic syntax check)
+      try {
+        delete require.cache[require.resolve(scriptPath)];
+        require(scriptPath);
+      } catch (error) {
+        throw new Error(`Script ${script} has syntax errors: ${error.message}`);
+      }
+    }
+    
+    runner.log('All scripts have valid syntax', 'debug');
+  });
+}
+
+async function testDownloadURLGeneration(runner) {
+  await runner.test('Download URL generation', async () => {
+    const { getPlatformInfo } = require('../scripts/install.js');
+    
+    const platformInfo = getPlatformInfo();
+    
+    // Test GitHub releases URL generation
+    const githubUrl = `https://github.com/danieleugenewilliams/local-memory-golang/releases/latest/download/${platformInfo.binaryName}`;
+    
+    // Test that URL is properly formatted
+    if (!githubUrl.includes(platformInfo.binaryName)) {
+      throw new Error('GitHub URL does not include binary name');
+    }
+    
+    if (!githubUrl.startsWith('https://')) {
+      throw new Error('GitHub URL is not HTTPS');
+    }
+    
+    runner.log(`Generated GitHub fallback URL: ${githubUrl}`, 'debug');
+    
+    // We don't test the actual download here to avoid network dependencies
+    // That will be tested in the integration test phase
+  });
+}
+
+async function testPackageJsonValidation(runner) {
+  await runner.test('package.json validation', async () => {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    
+    // Validate required fields
+    const requiredFields = [
+      'name', 'version', 'description', 'keywords', 'author', 'license',
+      'homepage', 'repository', 'bugs', 'engines', 'main', 'bin', 'scripts', 'files'
+    ];
+    
+    for (const field of requiredFields) {
+      if (!packageJson[field]) {
+        throw new Error(`Missing required field: ${field}`);
+      }
+    }
+    
+    // Validate specific values
+    if (!packageJson.keywords.includes('mcp')) {
+      throw new Error('Package should include "mcp" keyword');
+    }
+    
+    if (!packageJson.engines.node) {
+      throw new Error('Missing Node.js engine requirement');
+    }
+    
+    if (!packageJson.scripts.postinstall) {
+      throw new Error('Missing postinstall script');
+    }
+    
+    if (!packageJson.mcp || !packageJson.mcp.server) {
+      throw new Error('Missing MCP server metadata');
+    }
+    
+    runner.log('package.json validation passed', 'debug');
+  });
+}
+
+/**
+ * Main test runner
+ */
+async function runTests() {
+  const runner = new TestRunner();
+  
+  console.log('🧪 Local Memory NPM Package - Comprehensive Test Suite');
+  console.log('====================================================');
+  console.log(`Test directory: ${TEST_CONFIG.testDir}`);
+  console.log(`Verbose: ${TEST_CONFIG.verbose}`);
+  console.log(`Cleanup: ${TEST_CONFIG.cleanup}`);
+  console.log('');
+  
+  try {
+    // Structure and validation tests
+    await testPackageStructure(runner);
+    await testPackageJsonValidation(runner);
+    
+    // Platform and installation tests  
+    await testPlatformDetection(runner);
+    await testMainEntryPoint(runner);
+    await testScriptFunctionality(runner);
+    
+    // URL and download tests (without network)
+    await testDownloadURLGeneration(runner);
+    
+    // Installation simulation
+    await testInstallationSimulation(runner);
+    
+  } catch (error) {
+    runner.log(`Critical error: ${error.message}`, 'error');
+    if (TEST_CONFIG.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  } finally {
+    // Cleanup
+    if (TEST_CONFIG.cleanup && fs.existsSync(TEST_CONFIG.testDir)) {
+      try {
+        fs.rmSync(TEST_CONFIG.testDir, { recursive: true, force: true });
+        runner.log('Cleaned up test directory', 'debug');
+      } catch (error) {
+        runner.log(`Cleanup warning: ${error.message}`, 'warning');
+      }
+    }
+  }
+  
+  runner.summary();
+}
+
+// Run tests if executed directly
+if (require.main === module) {
+  runTests().catch(error => {
+    console.error('Test runner crashed:', error);
+    process.exit(1);
+  });
+}
+
+module.exports = { runTests, TestRunner };