exarch-rs 0.1.0 → 0.1.1

package/tests/creation-config.test.js

@@ -0,0 +1,97 @@
+/**
+ * Tests for CreationConfig class
+ */
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { CreationConfig } = require('../index.js');
+
+describe('CreationConfig', () => {
+  describe('constructor', () => {
+    it('should create config with defaults', () => {
+      const config = new CreationConfig();
+
+      assert.strictEqual(config.preservePermissions, true);
+      assert.strictEqual(config.followSymlinks, false);
+      assert.strictEqual(config.includeHidden, false);
+    });
+  });
+
+  describe('static default()', () => {
+    it('should return config equivalent to constructor', () => {
+      const config = CreationConfig.default();
+
+      assert.strictEqual(config.preservePermissions, true);
+      assert.strictEqual(config.followSymlinks, false);
+    });
+  });
+
+  describe('builder methods', () => {
+    it('should set compression level', () => {
+      const config = new CreationConfig();
+      config.setCompressionLevel(9);
+
+      assert.strictEqual(config.compressionLevel, 9);
+    });
+
+    it('should set preserve permissions', () => {
+      const config = new CreationConfig();
+      config.setPreservePermissions(false);
+
+      assert.strictEqual(config.preservePermissions, false);
+    });
+
+    it('should set follow symlinks', () => {
+      const config = new CreationConfig();
+      config.setFollowSymlinks(true);
+
+      assert.strictEqual(config.followSymlinks, true);
+    });
+
+    it('should set include hidden', () => {
+      const config = new CreationConfig();
+      config.setIncludeHidden(true);
+
+      assert.strictEqual(config.includeHidden, true);
+    });
+
+    it('should set max file size', () => {
+      const config = new CreationConfig();
+      config.setMaxFileSize(100 * 1024 * 1024);
+
+      assert.strictEqual(config.maxFileSize, 100 * 1024 * 1024);
+    });
+  });
+
+  describe('exclude patterns', () => {
+    it('should add exclude patterns', () => {
+      const config = new CreationConfig();
+      config.addExcludePattern('*.log');
+      config.addExcludePattern('node_modules');
+
+      assert.ok(config.excludePatterns.includes('*.log'));
+      assert.ok(config.excludePatterns.includes('node_modules'));
+    });
+  });
+
+  describe('compression levels', () => {
+    it('should accept valid compression levels 1-9', () => {
+      for (let level = 1; level <= 9; level++) {
+        const config = new CreationConfig();
+        config.setCompressionLevel(level);
+        assert.strictEqual(config.compressionLevel, level);
+      }
+    });
+
+    it('should throw on invalid compression level', () => {
+      const config = new CreationConfig();
+
+      assert.throws(() => {
+        config.setCompressionLevel(0);
+      }, /1.*9|invalid/i);
+
+      assert.throws(() => {
+        config.setCompressionLevel(10);
+      }, /1.*9|invalid/i);
+    });
+  });
+});

package/tests/extract.test.js

@@ -0,0 +1,118 @@
+/**
+ * Tests for archive extraction functions
+ *
+ * NOTE: Extraction tests are skipped until exarch-core extract_archive API is fully implemented.
+ * The current implementation is a placeholder (see exarch-core/src/api.rs).
+ */
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const {
+  extractArchive,
+  extractArchiveSync,
+  createArchiveSync,
+  SecurityConfig,
+} = require('../index.js');
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'exarch-test-'));
+}
+
+function createValidArchive(archivePath, tempDir) {
+  // Create source files
+  const sourceDir = path.join(tempDir, 'source');
+  fs.mkdirSync(sourceDir);
+  fs.writeFileSync(path.join(sourceDir, 'hello.txt'), 'Hello, World!');
+
+  // Create archive using our library
+  createArchiveSync(archivePath, [sourceDir]);
+}
+
+describe('extractArchive (async)', () => {
+  let tempDir;
+  let archivePath;
+  let outputDir;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+    outputDir = path.join(tempDir, 'output');
+    fs.mkdirSync(outputDir);
+  });
+
+  // TODO: Enable when core extract_archive is implemented
+  it.skip('should extract a valid archive', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = await extractArchive(archivePath, outputDir);
+
+    assert.ok(report.filesExtracted >= 1);
+    assert.ok(report.bytesWritten >= 13);
+    assert.ok(report.durationMs >= 0);
+  });
+
+  // TODO: Enable when core extract_archive is implemented
+  it.skip('should accept custom SecurityConfig', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const config = new SecurityConfig();
+    config.setMaxFileSize(1024 * 1024);
+    const report = await extractArchive(archivePath, outputDir, config);
+
+    assert.ok(report.filesExtracted >= 1);
+  });
+
+  it('should return empty report for valid archive (placeholder)', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = await extractArchive(archivePath, outputDir);
+
+    // Core extract_archive is currently a placeholder
+    assert.strictEqual(report.filesExtracted, 0);
+  });
+});
+
+describe('extractArchiveSync', () => {
+  let tempDir;
+  let archivePath;
+  let outputDir;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+    outputDir = path.join(tempDir, 'output');
+    fs.mkdirSync(outputDir);
+  });
+
+  // TODO: Enable when core extract_archive is implemented
+  it.skip('should extract a valid archive synchronously', () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = extractArchiveSync(archivePath, outputDir);
+
+    assert.ok(report.filesExtracted >= 1);
+    assert.ok(report.bytesWritten >= 13);
+  });
+
+  // TODO: Enable when core extract_archive is implemented
+  it.skip('should accept custom SecurityConfig', () => {
+    createValidArchive(archivePath, tempDir);
+
+    const config = new SecurityConfig();
+    config.setMaxFileCount(100);
+    const report = extractArchiveSync(archivePath, outputDir, config);
+
+    assert.ok(report.filesExtracted >= 1);
+  });
+
+  it('should return empty report for valid archive (placeholder)', () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = extractArchiveSync(archivePath, outputDir);
+
+    // Core extract_archive is currently a placeholder
+    assert.strictEqual(report.filesExtracted, 0);
+  });
+});

package/tests/list-verify.test.js

@@ -0,0 +1,148 @@
+/**
+ * Tests for listArchive and verifyArchive functions
+ */
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const {
+  listArchive,
+  listArchiveSync,
+  verifyArchive,
+  verifyArchiveSync,
+  createArchiveSync,
+  SecurityConfig,
+} = require('../index.js');
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'exarch-test-'));
+}
+
+function createValidArchive(archivePath, tempDir) {
+  // Create source files
+  const sourceDir = path.join(tempDir, 'source');
+  fs.mkdirSync(sourceDir);
+  fs.writeFileSync(path.join(sourceDir, 'hello.txt'), 'Hello, World!');
+
+  // Create archive using our library
+  createArchiveSync(archivePath, [sourceDir]);
+}
+
+describe('listArchive (async)', () => {
+  let tempDir;
+  let archivePath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+  });
+
+  it('should list archive contents', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const manifest = await listArchive(archivePath);
+
+    assert.ok(manifest.totalEntries >= 1);
+    assert.ok(manifest.entries.length >= 1);
+    // Find the hello.txt entry
+    const helloEntry = manifest.entries.find((e) => e.path.endsWith('hello.txt'));
+    assert.ok(helloEntry, 'should find hello.txt in archive');
+    assert.strictEqual(helloEntry.entryType, 'File');
+    assert.strictEqual(helloEntry.size, 13);
+  });
+
+  it('should accept custom SecurityConfig', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const config = new SecurityConfig();
+    const manifest = await listArchive(archivePath, config);
+
+    assert.ok(manifest.totalEntries >= 1);
+  });
+
+  it('should throw on non-existent archive', async () => {
+    await assert.rejects(
+      listArchive('/nonexistent/archive.tar.gz'),
+      /IO_ERROR|No such file|not found/i
+    );
+  });
+});
+
+describe('listArchiveSync', () => {
+  let tempDir;
+  let archivePath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+  });
+
+  it('should list archive contents synchronously', () => {
+    createValidArchive(archivePath, tempDir);
+
+    const manifest = listArchiveSync(archivePath);
+
+    assert.ok(manifest.totalEntries >= 1);
+    const helloEntry = manifest.entries.find((e) => e.path.endsWith('hello.txt'));
+    assert.ok(helloEntry, 'should find hello.txt in archive');
+  });
+});
+
+describe('verifyArchive (async)', () => {
+  let tempDir;
+  let archivePath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+  });
+
+  it('should verify a valid archive', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = await verifyArchive(archivePath);
+
+    assert.ok(['PASS', 'WARNING'].includes(report.status));
+    assert.ok(report.totalEntries >= 1);
+    assert.ok(report.integrityStatus);
+    assert.ok(report.securityStatus);
+    assert.ok(Array.isArray(report.issues));
+  });
+
+  it('should accept custom SecurityConfig', async () => {
+    createValidArchive(archivePath, tempDir);
+
+    const config = new SecurityConfig();
+    config.setMaxFileSize(1024);
+    const report = await verifyArchive(archivePath, config);
+
+    assert.ok(report.status);
+  });
+
+  it('should throw on non-existent archive', async () => {
+    await assert.rejects(
+      verifyArchive('/nonexistent/archive.tar.gz'),
+      /IO_ERROR|No such file|not found/i
+    );
+  });
+});
+
+describe('verifyArchiveSync', () => {
+  let tempDir;
+  let archivePath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    archivePath = path.join(tempDir, 'test.tar.gz');
+  });
+
+  it('should verify archive synchronously', () => {
+    createValidArchive(archivePath, tempDir);
+
+    const report = verifyArchiveSync(archivePath);
+
+    assert.ok(['PASS', 'WARNING'].includes(report.status));
+    assert.ok(report.totalEntries >= 1);
+  });
+});

package/tests/security-config.test.js

@@ -0,0 +1,187 @@
+/**
+ * Tests for SecurityConfig class
+ */
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { SecurityConfig } = require('../index.js');
+
+describe('SecurityConfig', () => {
+  describe('constructor', () => {
+    it('should create config with secure defaults', () => {
+      const config = new SecurityConfig();
+
+      assert.strictEqual(config.allowSymlinks, false);
+      assert.strictEqual(config.allowHardlinks, false);
+      assert.strictEqual(config.allowAbsolutePaths, false);
+      assert.strictEqual(config.allowWorldWritable, false);
+      assert.strictEqual(config.preservePermissions, false);
+    });
+
+    it('should have default size limits', () => {
+      const config = new SecurityConfig();
+
+      assert.strictEqual(config.maxFileSize, 50 * 1024 * 1024); // 50 MB
+      assert.strictEqual(config.maxTotalSize, 500 * 1024 * 1024); // 500 MB
+      assert.strictEqual(config.maxFileCount, 10000);
+      assert.strictEqual(config.maxPathDepth, 32);
+      assert.strictEqual(config.maxCompressionRatio, 100.0);
+    });
+  });
+
+  describe('static default()', () => {
+    it('should return config equivalent to constructor', () => {
+      const config = SecurityConfig.default();
+
+      assert.strictEqual(config.allowSymlinks, false);
+      assert.strictEqual(config.maxFileCount, 10000);
+    });
+  });
+
+  describe('static permissive()', () => {
+    it('should return permissive configuration', () => {
+      const config = SecurityConfig.permissive();
+
+      assert.strictEqual(config.allowSymlinks, true);
+      assert.strictEqual(config.allowHardlinks, true);
+      assert.strictEqual(config.allowAbsolutePaths, true);
+      assert.strictEqual(config.allowWorldWritable, true);
+    });
+  });
+
+  describe('builder methods', () => {
+    it('should set max file size', () => {
+      const config = new SecurityConfig();
+      config.setMaxFileSize(100 * 1024 * 1024);
+
+      assert.strictEqual(config.maxFileSize, 100 * 1024 * 1024);
+    });
+
+    it('should set max total size', () => {
+      const config = new SecurityConfig();
+      config.setMaxTotalSize(1024 * 1024 * 1024);
+
+      assert.strictEqual(config.maxTotalSize, 1024 * 1024 * 1024);
+    });
+
+    it('should set max file count', () => {
+      const config = new SecurityConfig();
+      config.setMaxFileCount(50000);
+
+      assert.strictEqual(config.maxFileCount, 50000);
+    });
+
+    it('should set max path depth', () => {
+      const config = new SecurityConfig();
+      config.setMaxPathDepth(64);
+
+      assert.strictEqual(config.maxPathDepth, 64);
+    });
+
+    it('should set max compression ratio', () => {
+      const config = new SecurityConfig();
+      config.setMaxCompressionRatio(50.0);
+
+      assert.strictEqual(config.maxCompressionRatio, 50.0);
+    });
+
+    it('should set allow symlinks', () => {
+      const config = new SecurityConfig();
+      config.setAllowSymlinks(true);
+
+      assert.strictEqual(config.allowSymlinks, true);
+    });
+
+    it('should set allow hardlinks', () => {
+      const config = new SecurityConfig();
+      config.setAllowHardlinks(true);
+
+      assert.strictEqual(config.allowHardlinks, true);
+    });
+
+    it('should set allow absolute paths', () => {
+      const config = new SecurityConfig();
+      config.setAllowAbsolutePaths(true);
+
+      assert.strictEqual(config.allowAbsolutePaths, true);
+    });
+
+    it('should set allow world writable', () => {
+      const config = new SecurityConfig();
+      config.setAllowWorldWritable(true);
+
+      assert.strictEqual(config.allowWorldWritable, true);
+    });
+
+    it('should set preserve permissions', () => {
+      const config = new SecurityConfig();
+      config.setPreservePermissions(true);
+
+      assert.strictEqual(config.preservePermissions, true);
+    });
+  });
+
+  describe('extension filtering', () => {
+    it('should add allowed extensions', () => {
+      const config = new SecurityConfig();
+      config.addAllowedExtension('txt');
+      config.addAllowedExtension('md');
+
+      assert.ok(config.allowedExtensions.includes('txt'));
+      assert.ok(config.allowedExtensions.includes('md'));
+    });
+
+    it('should check extension allowed', () => {
+      const config = new SecurityConfig();
+      config.addAllowedExtension('txt');
+
+      assert.strictEqual(config.isExtensionAllowed('txt'), true);
+      assert.strictEqual(config.isExtensionAllowed('exe'), false);
+    });
+
+    it('should allow all extensions when none specified', () => {
+      const config = new SecurityConfig();
+
+      assert.strictEqual(config.isExtensionAllowed('txt'), true);
+      assert.strictEqual(config.isExtensionAllowed('exe'), true);
+    });
+  });
+
+  describe('path component banning', () => {
+    it('should add banned components', () => {
+      const config = new SecurityConfig();
+      config.addBannedComponent('.secret');
+
+      assert.ok(config.bannedPathComponents.includes('.secret'));
+    });
+
+    it('should check path component allowed', () => {
+      const config = new SecurityConfig();
+      config.addBannedComponent('.secret');
+
+      assert.strictEqual(config.isPathComponentAllowed('src'), true);
+      assert.strictEqual(config.isPathComponentAllowed('.secret'), false);
+    });
+  });
+
+  describe('validation', () => {
+    it('should throw on invalid compression ratio', () => {
+      const config = new SecurityConfig();
+
+      assert.throws(() => {
+        config.setMaxCompressionRatio(-1);
+      }, /positive/i);
+
+      assert.throws(() => {
+        config.setMaxCompressionRatio(Infinity);
+      }, /finite/i);
+    });
+
+    it('should throw on negative file size', () => {
+      const config = new SecurityConfig();
+
+      assert.throws(() => {
+        config.setMaxFileSize(-1);
+      }, /negative/i);
+    });
+  });
+});