236 lines
7.8 KiB
TypeScript
236 lines
7.8 KiB
TypeScript
/**
|
|
* Tests for Memory provider
|
|
*/
|
|
|
|
import { tap, expect } from '@push.rocks/tapbundle';
|
|
import { SmartFs, SmartFsProviderMemory } from '../ts/index.js';
|
|
|
|
// Create test instance
|
|
const memoryProvider = new SmartFsProviderMemory();
|
|
const fs = new SmartFs(memoryProvider);
|
|
|
|
tap.test('should create SmartFS instance with Memory provider', async () => {
|
|
expect(fs).toBeInstanceOf(SmartFs);
|
|
expect(fs.getProviderName()).toEqual('memory');
|
|
});
|
|
|
|
tap.test('should write and read a file', async () => {
|
|
await fs.file('/test.txt').write('Hello, World!');
|
|
const content = await fs.file('/test.txt').encoding('utf8').read();
|
|
expect(content).toEqual('Hello, World!');
|
|
});
|
|
|
|
tap.test('should write and read a file with encoding', async () => {
|
|
await fs.file('/test2.txt').encoding('utf8').write('Test content');
|
|
const content = await fs.file('/test2.txt').encoding('utf8').read();
|
|
expect(content).toEqual('Test content');
|
|
});
|
|
|
|
tap.test('should check if file exists', async () => {
|
|
const exists = await fs.file('/test.txt').exists();
|
|
expect(exists).toEqual(true);
|
|
|
|
const notExists = await fs.file('/nonexistent.txt').exists();
|
|
expect(notExists).toEqual(false);
|
|
});
|
|
|
|
tap.test('should get file stats', async () => {
|
|
await fs.file('/stats-test.txt').write('stats test');
|
|
const stats = await fs.file('/stats-test.txt').stat();
|
|
|
|
expect(stats).toHaveProperty('size');
|
|
expect(stats).toHaveProperty('mtime');
|
|
expect(stats).toHaveProperty('birthtime');
|
|
expect(stats.isFile).toEqual(true);
|
|
expect(stats.isDirectory).toEqual(false);
|
|
});
|
|
|
|
tap.test('should append to a file', async () => {
|
|
await fs.file('/append-test.txt').write('Hello');
|
|
await fs.file('/append-test.txt').append(' World!');
|
|
const content = await fs.file('/append-test.txt').encoding('utf8').read();
|
|
expect(content).toEqual('Hello World!');
|
|
});
|
|
|
|
tap.test('should delete a file', async () => {
|
|
await fs.file('/delete-test.txt').write('to be deleted');
|
|
await fs.file('/delete-test.txt').delete();
|
|
const exists = await fs.file('/delete-test.txt').exists();
|
|
expect(exists).toEqual(false);
|
|
});
|
|
|
|
tap.test('should copy a file', async () => {
|
|
await fs.file('/copy-source.txt').write('copy me');
|
|
await fs.file('/copy-source.txt').copy('/copy-dest.txt');
|
|
|
|
const sourceContent = await fs.file('/copy-source.txt').encoding('utf8').read();
|
|
const destContent = await fs.file('/copy-dest.txt').encoding('utf8').read();
|
|
|
|
expect(sourceContent).toEqual('copy me');
|
|
expect(destContent).toEqual('copy me');
|
|
});
|
|
|
|
tap.test('should move a file', async () => {
|
|
await fs.file('/move-source.txt').write('move me');
|
|
await fs.file('/move-source.txt').move('/move-dest.txt');
|
|
|
|
const sourceExists = await fs.file('/move-source.txt').exists();
|
|
const destContent = await fs.file('/move-dest.txt').encoding('utf8').read();
|
|
|
|
expect(sourceExists).toEqual(false);
|
|
expect(destContent).toEqual('move me');
|
|
});
|
|
|
|
tap.test('should create a directory', async () => {
|
|
await fs.directory('/test-dir').create();
|
|
const exists = await fs.directory('/test-dir').exists();
|
|
expect(exists).toEqual(true);
|
|
});
|
|
|
|
tap.test('should create nested directories recursively', async () => {
|
|
await fs.directory('/nested/deep/path').recursive().create();
|
|
const exists = await fs.directory('/nested/deep/path').exists();
|
|
expect(exists).toEqual(true);
|
|
});
|
|
|
|
tap.test('should list directory contents', async () => {
|
|
await fs.directory('/list-test').create();
|
|
await fs.file('/list-test/file1.txt').write('file1');
|
|
await fs.file('/list-test/file2.txt').write('file2');
|
|
await fs.directory('/list-test/subdir').create();
|
|
|
|
const entries = await fs.directory('/list-test').list();
|
|
|
|
expect(entries).toHaveLength(3);
|
|
const names = entries.map((e) => e.name).sort();
|
|
expect(names).toEqual(['file1.txt', 'file2.txt', 'subdir']);
|
|
});
|
|
|
|
tap.test('should list directory contents recursively', async () => {
|
|
await fs.directory('/recursive-test').create();
|
|
await fs.file('/recursive-test/file1.txt').write('file1');
|
|
await fs.directory('/recursive-test/subdir').create();
|
|
await fs.file('/recursive-test/subdir/file2.txt').write('file2');
|
|
|
|
const entries = await fs.directory('/recursive-test').recursive().list();
|
|
|
|
expect(entries.length).toBeGreaterThanOrEqual(3);
|
|
});
|
|
|
|
tap.test('should filter directory listings', async () => {
|
|
await fs.directory('/filter-test').create();
|
|
await fs.file('/filter-test/file1.ts').write('ts file');
|
|
await fs.file('/filter-test/file2.js').write('js file');
|
|
await fs.file('/filter-test/file3.ts').write('ts file');
|
|
|
|
const entries = await fs.directory('/filter-test').filter('*.ts').list();
|
|
|
|
expect(entries).toHaveLength(2);
|
|
expect(entries.every((e) => e.name.endsWith('.ts'))).toEqual(true);
|
|
});
|
|
|
|
tap.test('should delete a directory recursively', async () => {
|
|
await fs.directory('/delete-dir-test').create();
|
|
await fs.file('/delete-dir-test/file.txt').write('file');
|
|
await fs.directory('/delete-dir-test/subdir').create();
|
|
|
|
await fs.directory('/delete-dir-test').recursive().delete();
|
|
|
|
const exists = await fs.directory('/delete-dir-test').exists();
|
|
expect(exists).toEqual(false);
|
|
});
|
|
|
|
tap.test('should handle file streams', async () => {
|
|
const testData = 'Stream test data with some content';
|
|
await fs.file('/stream-test.txt').write(testData);
|
|
|
|
const readStream = await fs.file('/stream-test.txt').readStream();
|
|
const chunks: Uint8Array[] = [];
|
|
|
|
const reader = readStream.getReader();
|
|
let done = false;
|
|
|
|
while (!done) {
|
|
const result = await reader.read();
|
|
done = result.done;
|
|
if (result.value) {
|
|
chunks.push(result.value);
|
|
}
|
|
}
|
|
|
|
const buffer = Buffer.concat(chunks.map((c) => Buffer.from(c)));
|
|
const content = buffer.toString('utf8');
|
|
|
|
expect(content).toEqual(testData);
|
|
});
|
|
|
|
tap.test('should write file streams', async () => {
|
|
const testData = 'Writing via stream';
|
|
const buffer = Buffer.from(testData);
|
|
|
|
const writeStream = await fs.file('/write-stream-test.txt').writeStream();
|
|
const writer = writeStream.getWriter();
|
|
|
|
await writer.write(new Uint8Array(buffer));
|
|
await writer.close();
|
|
|
|
const content = await fs.file('/write-stream-test.txt').encoding('utf8').read();
|
|
expect(content).toEqual(testData);
|
|
});
|
|
|
|
tap.test('should execute transactions', async () => {
|
|
await fs
|
|
.transaction()
|
|
.file('/tx-file1.txt')
|
|
.write('transaction file 1')
|
|
.file('/tx-file2.txt')
|
|
.write('transaction file 2')
|
|
.file('/tx-file3.txt')
|
|
.write('transaction file 3')
|
|
.commit();
|
|
|
|
const content1 = await fs.file('/tx-file1.txt').encoding('utf8').read();
|
|
const content2 = await fs.file('/tx-file2.txt').encoding('utf8').read();
|
|
const content3 = await fs.file('/tx-file3.txt').encoding('utf8').read();
|
|
|
|
expect(content1).toEqual('transaction file 1');
|
|
expect(content2).toEqual('transaction file 2');
|
|
expect(content3).toEqual('transaction file 3');
|
|
});
|
|
|
|
tap.test('should rollback transactions on error', async () => {
|
|
// This test verifies that transaction operations are prepared with backups
|
|
// Since memory provider doesn't naturally fail, we just verify the mechanism exists
|
|
await fs.file('/tx-rollback-test.txt').write('original');
|
|
|
|
const tx = fs.transaction();
|
|
tx.file('/tx-rollback-test.txt').write('modified');
|
|
|
|
// Verify operations are tracked
|
|
const operations = tx.getOperations();
|
|
expect(operations.length).toEqual(1);
|
|
expect(operations[0].type).toEqual('write');
|
|
|
|
// Commit normally (rollback test would require mocking provider failure)
|
|
await tx.commit();
|
|
expect(tx.isCommitted()).toEqual(true);
|
|
});
|
|
|
|
tap.test('should handle file watching', async () => {
|
|
await fs.file('/watch-test.txt').write('initial');
|
|
|
|
// Create watcher (verifies the API works)
|
|
const watcher = await fs
|
|
.watch('/watch-test.txt')
|
|
.onChange((event) => {
|
|
// Event handler registered
|
|
})
|
|
.start();
|
|
|
|
// Verify watcher can be stopped
|
|
await watcher.stop();
|
|
expect(true).toEqual(true); // Test passes if we get here
|
|
});
|
|
|
|
export default tap.start();
|