• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Flags: --experimental-abortcontroller
2'use strict';
3
4const common = require('../common');
5const fs = require('fs');
6const fsPromises = fs.promises;
7const path = require('path');
8const tmpdir = require('../common/tmpdir');
9const assert = require('assert');
10const tmpDir = tmpdir.path;
11const { Readable } = require('stream');
12
13tmpdir.refresh();
14
15const dest = path.resolve(tmpDir, 'tmp.txt');
16const otherDest = path.resolve(tmpDir, 'tmp-2.txt');
17const buffer = Buffer.from('abc'.repeat(1000));
18const buffer2 = Buffer.from('xyz'.repeat(1000));
19const stream = Readable.from(['a', 'b', 'c']);
20const stream2 = Readable.from(['ümlaut', ' ', 'sechzig']);
21const iterable = {
22  expected: 'abc',
23  *[Symbol.iterator]() {
24    yield 'a';
25    yield 'b';
26    yield 'c';
27  }
28};
29function iterableWith(value) {
30  return {
31    *[Symbol.iterator]() {
32      yield value;
33    }
34  };
35}
36const bufferIterable = {
37  expected: 'abc',
38  *[Symbol.iterator]() {
39    yield Buffer.from('a');
40    yield Buffer.from('b');
41    yield Buffer.from('c');
42  }
43};
44const asyncIterable = {
45  expected: 'abc',
46  async* [Symbol.asyncIterator]() {
47    yield 'a';
48    yield 'b';
49    yield 'c';
50  }
51};
52
53async function doWrite() {
54  await fsPromises.writeFile(dest, buffer);
55  const data = fs.readFileSync(dest);
56  assert.deepStrictEqual(data, buffer);
57}
58
59async function doWriteStream() {
60  await fsPromises.writeFile(dest, stream);
61  const expected = 'abc';
62  const data = fs.readFileSync(dest, 'utf-8');
63  assert.deepStrictEqual(data, expected);
64}
65
66async function doWriteStreamWithCancel() {
67  const controller = new AbortController();
68  const { signal } = controller;
69  process.nextTick(() => controller.abort());
70  await assert.rejects(
71    fsPromises.writeFile(otherDest, stream, { signal }),
72    { name: 'AbortError' }
73  );
74}
75
76async function doWriteIterable() {
77  await fsPromises.writeFile(dest, iterable);
78  const data = fs.readFileSync(dest, 'utf-8');
79  assert.deepStrictEqual(data, iterable.expected);
80}
81
82async function doWriteInvalidIterable() {
83  await Promise.all(
84    [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
85      assert.rejects(fsPromises.writeFile(dest, iterableWith(value)), {
86        code: 'ERR_INVALID_ARG_TYPE',
87      })
88    )
89  );
90}
91
92async function doWriteIterableWithEncoding() {
93  await fsPromises.writeFile(dest, stream2, 'latin1');
94  const expected = 'ümlaut sechzig';
95  const data = fs.readFileSync(dest, 'latin1');
96  assert.deepStrictEqual(data, expected);
97}
98
99async function doWriteBufferIterable() {
100  await fsPromises.writeFile(dest, bufferIterable);
101  const data = fs.readFileSync(dest, 'utf-8');
102  assert.deepStrictEqual(data, bufferIterable.expected);
103}
104
105async function doWriteAsyncIterable() {
106  await fsPromises.writeFile(dest, asyncIterable);
107  const data = fs.readFileSync(dest, 'utf-8');
108  assert.deepStrictEqual(data, asyncIterable.expected);
109}
110
111async function doWriteInvalidValues() {
112  await Promise.all(
113    [42, 42n, {}, Symbol('42'), true, undefined, null, NaN].map((value) =>
114      assert.rejects(fsPromises.writeFile(dest, value), {
115        code: 'ERR_INVALID_ARG_TYPE',
116      })
117    )
118  );
119}
120
121async function doWriteWithCancel() {
122  const controller = new AbortController();
123  const { signal } = controller;
124  process.nextTick(() => controller.abort());
125  await assert.rejects(
126    fsPromises.writeFile(otherDest, buffer, { signal }),
127    { name: 'AbortError' }
128  );
129}
130
131async function doAppend() {
132  await fsPromises.appendFile(dest, buffer2, { flag: null });
133  const data = fs.readFileSync(dest);
134  const buf = Buffer.concat([buffer, buffer2]);
135  assert.deepStrictEqual(buf, data);
136}
137
138async function doRead() {
139  const data = await fsPromises.readFile(dest);
140  const buf = fs.readFileSync(dest);
141  assert.deepStrictEqual(buf, data);
142}
143
144async function doReadWithEncoding() {
145  const data = await fsPromises.readFile(dest, 'utf-8');
146  const syncData = fs.readFileSync(dest, 'utf-8');
147  assert.strictEqual(typeof data, 'string');
148  assert.deepStrictEqual(data, syncData);
149}
150
151(async () => {
152  await doWrite();
153  await doWriteWithCancel();
154  await doAppend();
155  await doRead();
156  await doReadWithEncoding();
157  await doWriteStream();
158  await doWriteStreamWithCancel();
159  await doWriteIterable();
160  await doWriteInvalidIterable();
161  await doWriteIterableWithEncoding();
162  await doWriteBufferIterable();
163  await doWriteAsyncIterable();
164  await doWriteInvalidValues();
165})().then(common.mustCall());
166