test: add FastUtf8Stream tests

Author: mertcanaltin

test/parallel/test-fastutf8stream-destroy.js

@@ -0,0 +1,125 @@
+'use strict';
+
+require('../common');
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const { FastUtf8Stream } = require('node:fs');
+const { tmpdir } = require('node:os');
+const path = require('node:path');
+
+let fileCounter = 0;
+
+function getTempFile() {
+  return path.join(tmpdir(), `fastutf8stream-${process.pid}-${Date.now()}-${fileCounter++}.log`);
+}
+
+test('FastUtf8Stream destroy - basic functionality', async (t) => {
+  // Reset the umask for testing
+  process.umask(0o000);
+
+  const dest = getTempFile();
+  const fd = fs.openSync(dest, 'w');
+  const stream = new FastUtf8Stream({ fd, sync: false });
+
+  // Test successful write
+  const writeResult = stream.write('hello world\n');
+  assert.ok(writeResult);
+
+  // Destroy the stream
+  stream.destroy();
+
+  // Test that write throws after destroy
+  assert.throws(() => {
+    stream.write('hello world\n');
+  }, Error);
+
+  // Wait for file to be written and check content
+  await new Promise((resolve, reject) => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      if (err) reject(err);
+      else {
+        assert.strictEqual(data, 'hello world\n');
+        resolve();
+      }
+    });
+  });
+
+  // Test events - use Promise to handle async events
+  const eventPromises = [];
+
+  // Finish event should NOT be emitted after destroy
+  eventPromises.push(new Promise((resolve) => {
+    const finishTimeout = setTimeout(() => {
+      resolve('finish not emitted'); // This is what we want
+    }, 100);
+
+    stream.on('finish', () => {
+      clearTimeout(finishTimeout);
+      resolve('finish emitted');
+    });
+  }));
+
+  // Close event SHOULD be emitted after destroy
+  eventPromises.push(new Promise((resolve) => {
+    stream.on('close', () => {
+      resolve('close emitted');
+    });
+  }));
+
+  const [finishResult, closeResult] = await Promise.all(eventPromises);
+
+  assert.strictEqual(finishResult, 'finish not emitted');
+  assert.strictEqual(closeResult, 'close emitted');
+
+  // Cleanup
+  try {
+    fs.unlinkSync(dest);
+  } catch (err) {
+    console.warn('Cleanup error:', err.message);
+  }
+});
+
+test('FastUtf8Stream destroy - sync mode', async (t) => {
+  process.umask(0o000);
+
+  const dest = getTempFile();
+  const fd = fs.openSync(dest, 'w');
+  const stream = new FastUtf8Stream({ fd, sync: true });
+
+  assert.ok(stream.write('hello world\n'));
+  stream.destroy();
+  assert.throws(() => { stream.write('hello world\n'); }, Error);
+
+  const data = fs.readFileSync(dest, 'utf8');
+  assert.strictEqual(data, 'hello world\n');
+
+  // Cleanup
+  try {
+    fs.unlinkSync(dest);
+  } catch (err) {
+    console.warn('Cleanup error:', err.message);
+  }
+});
+
+test('FastUtf8Stream destroy while opening', async (t) => {
+  const dest = getTempFile();
+  const stream = new FastUtf8Stream({ dest });
+
+  // Destroy immediately while opening
+  stream.destroy();
+
+  // Wait for close event
+  await new Promise((resolve) => {
+    stream.on('close', () => {
+      resolve();
+    });
+  });
+
+  // Cleanup
+  try {
+    fs.unlinkSync(dest);
+  } catch (err) {
+    console.warn('Cleanup error:', err.message);
+  }
+});

test/parallel/test-fastutf8stream-end.js

@@ -0,0 +1,165 @@
+'use strict';
+
+require('../common');
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const { FastUtf8Stream } = require('node:fs');
+const { tmpdir } = require('node:os');
+const path = require('node:path');
+
+let fileCounter = 0;
+
+function getTempFile() {
+  return path.join(tmpdir(), `fastutf8stream-${process.pid}-${Date.now()}-${fileCounter++}.log`);
+}
+
+function runTests(buildTests) {
+  buildTests(test, false);
+  buildTests(test, true);
+}
+
+runTests(buildTests);
+
+function buildTests(test, sync) {
+  // Reset the umask for testing
+  process.umask(0o000);
+
+  test(`end after reopen - sync: ${sync}`, async (t) => {
+    const dest = getTempFile();
+    const stream = new FastUtf8Stream({ dest, minLength: 4096, sync });
+
+    await new Promise((resolve) => {
+      stream.once('ready', () => {
+        const after = dest + '-moved';
+        stream.reopen(after);
+        stream.write('after reopen\n');
+        stream.on('finish', () => {
+          fs.readFile(after, 'utf8', (err, data) => {
+            assert.ifError(err);
+            assert.strictEqual(data, 'after reopen\n');
+
+            // Cleanup
+            try {
+              fs.unlinkSync(dest);
+              fs.unlinkSync(after);
+            } catch (err) {
+              console.warn('Cleanup error:', err.message);
+            }
+
+            resolve();
+          });
+        });
+        stream.end();
+      });
+    });
+  });
+
+  test(`end after 2x reopen - sync: ${sync}`, async (t) => {
+    const dest = getTempFile();
+    const stream = new FastUtf8Stream({ dest, minLength: 4096, sync });
+
+    await new Promise((resolve) => {
+      stream.once('ready', () => {
+        stream.reopen(dest + '-moved');
+        const after = dest + '-moved-moved';
+        stream.reopen(after);
+        stream.write('after reopen\n');
+        stream.on('finish', () => {
+          fs.readFile(after, 'utf8', (err, data) => {
+            assert.ifError(err);
+            assert.strictEqual(data, 'after reopen\n');
+
+            // Cleanup
+            try {
+              fs.unlinkSync(dest);
+              fs.unlinkSync(dest + '-moved');
+              fs.unlinkSync(after);
+            } catch (err) {
+              console.warn('Cleanup error:', err.message);
+            }
+
+            resolve();
+          });
+        });
+        stream.end();
+      });
+    });
+  });
+
+  test(`end if not ready - sync: ${sync}`, async (t) => {
+    const dest = getTempFile();
+    const stream = new FastUtf8Stream({ dest, minLength: 4096, sync });
+    const after = dest + '-moved';
+
+    stream.reopen(after);
+    stream.write('after reopen\n');
+
+    await new Promise((resolve) => {
+      stream.on('finish', () => {
+        fs.readFile(after, 'utf8', (err, data) => {
+          assert.ifError(err);
+          assert.strictEqual(data, 'after reopen\n');
+
+          // Cleanup
+          try {
+            fs.unlinkSync(dest);
+            fs.unlinkSync(after);
+          } catch {
+            // Ignore cleanup errors
+          }
+
+          resolve();
+        });
+      });
+
+      stream.end();
+    });
+  });
+
+  test(`large data write - sync: ${sync}`, async (t) => {
+    const dest = getTempFile();
+    const stream = new FastUtf8Stream({ dest, sync });
+    const str = Buffer.alloc(10000).fill('a').toString();
+
+    let totalWritten = 0;
+    const writeData = () => {
+      if (totalWritten >= 10000) {
+        stream.end();
+        return;
+      }
+
+      const chunk = str.slice(totalWritten, totalWritten + 1000);
+      if (stream.write(chunk)) {
+        totalWritten += chunk.length;
+        setImmediate(writeData);
+      } else {
+        stream.once('drain', () => {
+          totalWritten += chunk.length;
+          setImmediate(writeData);
+        });
+      }
+    };
+
+    await new Promise((resolve) => {
+      stream.on('finish', () => {
+        fs.readFile(dest, 'utf8', (err, data) => {
+          assert.ifError(err);
+          assert.strictEqual(data.length, 10000);
+          assert.strictEqual(data, str);
+
+          // Cleanup
+          try {
+            fs.unlinkSync(dest);
+          } catch {
+            // Ignore cleanup errors
+          }
+
+          resolve();
+        });
+      });
+
+      writeData();
+    });
+  });
+}