/
test-fs-promises-writefile.js
112 lines (99 loc) Β· 3.01 KB
/
test-fs-promises-writefile.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
'use strict';
const common = require('../common');
const fs = require('fs');
const fsPromises = fs.promises;
const path = require('path');
const tmpdir = require('../common/tmpdir');
const assert = require('assert');
const tmpDir = tmpdir.path;
const { Readable } = require('stream');
tmpdir.refresh();
const dest = path.resolve(tmpDir, 'tmp.txt');
const otherDest = path.resolve(tmpDir, 'tmp-2.txt');
const buffer = Buffer.from('abc'.repeat(1000));
const buffer2 = Buffer.from('xyz'.repeat(1000));
const stream = Readable.from(['a', 'b', 'c']);
const stream2 = Readable.from(['a', 'b', 'c']);
const iterable = {
[Symbol.iterator]: function*() {
yield 'a';
yield 'b';
yield 'c';
}
};
const asyncIterable = {
async* [Symbol.asyncIterator]() {
yield 'a';
yield 'b';
yield 'c';
}
};
async function doWrite() {
await fsPromises.writeFile(dest, buffer);
const data = fs.readFileSync(dest);
assert.deepStrictEqual(data, buffer);
}
async function doWriteStream() {
await fsPromises.writeFile(dest, stream);
let expected = '';
for await (const v of stream2) expected += v;
const data = fs.readFileSync(dest, 'utf-8');
assert.deepStrictEqual(data, expected);
}
async function doWriteStreamWithCancel() {
const controller = new AbortController();
const { signal } = controller;
process.nextTick(() => controller.abort());
assert.rejects(fsPromises.writeFile(otherDest, stream, { signal }), {
name: 'AbortError'
});
}
async function doWriteIterable() {
await fsPromises.writeFile(dest, iterable);
let expected = '';
for await (const v of iterable) expected += v;
const data = fs.readFileSync(dest, 'utf-8');
assert.deepStrictEqual(data, expected);
}
async function doWriteAsyncIterable() {
await fsPromises.writeFile(dest, asyncIterable);
let expected = '';
for await (const v of asyncIterable) expected += v;
const data = fs.readFileSync(dest, 'utf-8');
assert.deepStrictEqual(data, expected);
}
async function doWriteWithCancel() {
const controller = new AbortController();
const { signal } = controller;
process.nextTick(() => controller.abort());
assert.rejects(fsPromises.writeFile(otherDest, buffer, { signal }), {
name: 'AbortError'
});
}
async function doAppend() {
await fsPromises.appendFile(dest, buffer2, { flag: null });
const data = fs.readFileSync(dest);
const buf = Buffer.concat([buffer, buffer2]);
assert.deepStrictEqual(buf, data);
}
async function doRead() {
const data = await fsPromises.readFile(dest);
const buf = fs.readFileSync(dest);
assert.deepStrictEqual(buf, data);
}
async function doReadWithEncoding() {
const data = await fsPromises.readFile(dest, 'utf-8');
const syncData = fs.readFileSync(dest, 'utf-8');
assert.strictEqual(typeof data, 'string');
assert.deepStrictEqual(data, syncData);
}
doWrite()
.then(doWriteWithCancel)
.then(doAppend)
.then(doRead)
.then(doReadWithEncoding)
.then(doWriteStream)
.then(doWriteStreamWithCancel)
.then(doWriteIterable)
.then(doWriteAsyncIterable)
.then(common.mustCall());