node/test/parallel/test-fs-write-file-flush.js at 1dcd042e1a496536dd4fd3d006639eab214846ac · nodejs/node · GitHub

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
'use strict';
const common = require('../common');
const tmpdir = require('../common/tmpdir');
const assert = require('node:assert');
const fs = require('node:fs');
const fsp = require('node:fs/promises');
const test = require('node:test');
const data = 'foo';
const data2 = 'bar';
let cnt = 0;

function nextFile() {
  return tmpdir.resolve(`${cnt++}.out`);
}

tmpdir.refresh();

test('synchronous version', async (t) => {
  await t.test('validation', (t) => {
    for (const v of ['true', '', 0, 1, [], {}, Symbol()]) {
      assert.throws(() => {
        fs.writeFileSync(nextFile(), data, { flush: v });
      }, { code: 'ERR_INVALID_ARG_TYPE' });
    }
  });

  await t.test('performs flush', (t) => {
    const spy = t.mock.method(fs, 'fsyncSync');
    const checkCalls = common.mustCall((expected) => {
      const calls = spy.mock.calls;
      assert.strictEqual(calls.length, expected);
      if (expected === 0) return;
      assert.strictEqual(calls.at(-1).result, undefined);
      assert.strictEqual(calls.at(-1).error, undefined);
      assert.strictEqual(calls.at(-1).arguments.length, 1);
      assert.strictEqual(typeof calls.at(-1).arguments[0], 'number');
    }, 4);

    const file = nextFile();

    checkCalls(0);
    fs.writeFileSync(file, data, { flush: true });
    checkCalls(1);
    assert.strictEqual(fs.readFileSync(file, 'utf8'), data);

    checkCalls(1);
    fs.writeFileSync(file, data2, { flush: true, encoding: 'utf8' });
    checkCalls(2);
    assert.strictEqual(fs.readFileSync(file, 'utf8'), data2);
  });

  await t.test('does not perform flush', (t) => {
    const spy = t.mock.method(fs, 'fsyncSync');

    for (const v of [undefined, null, false]) {
      const file = nextFile();
      fs.writeFileSync(file, data, { flush: v });
      assert.strictEqual(fs.readFileSync(file, 'utf8'), data);
    }

    assert.strictEqual(spy.mock.calls.length, 0);
  });
});

test('callback version', async (t) => {
  await t.test('validation', (t) => {
    for (const v of ['true', '', 0, 1, [], {}, Symbol()]) {
      assert.throws(() => {
        fs.writeFileSync(nextFile(), data, { flush: v });
      }, { code: 'ERR_INVALID_ARG_TYPE' });
    }
  });

  await t.test('performs flush', (t, done) => {
    const spy = t.mock.method(fs, 'fsync');
    const file = nextFile();
    fs.writeFile(file, data, { flush: true }, common.mustSucceed(() => {
      const calls = spy.mock.calls;
      assert.strictEqual(calls.length, 1);
      assert.strictEqual(calls[0].result, undefined);
      assert.strictEqual(calls[0].error, undefined);
      assert.strictEqual(calls[0].arguments.length, 2);
      assert.strictEqual(typeof calls[0].arguments[0], 'number');
      assert.strictEqual(typeof calls[0].arguments[1], 'function');
      assert.strictEqual(fs.readFileSync(file, 'utf8'), data);
      done();
    }));
  });

  await t.test('does not perform flush', (t, done) => {
    const values = [undefined, null, false];
    const spy = t.mock.method(fs, 'fsync');
    let cnt = 0;

    for (const v of values) {
      const file = nextFile();

      fs.writeFile(file, data, { flush: v }, common.mustSucceed(() => {
        assert.strictEqual(fs.readFileSync(file, 'utf8'), data);
        cnt++;

        if (cnt === values.length) {
          assert.strictEqual(spy.mock.calls.length, 0);
          done();
        }
      }));
    }
  });
});

test('promise based version', async (t) => {
  await t.test('validation', async (t) => {
    for (const v of ['true', '', 0, 1, [], {}, Symbol()]) {
      await assert.rejects(() => {
        return fsp.writeFile(nextFile(), data, { flush: v });
      }, { code: 'ERR_INVALID_ARG_TYPE' });
    }
  });

  await t.test('success path', async (t) => {
    for (const v of [undefined, null, false, true]) {
      const file = nextFile();
      await fsp.writeFile(file, data, { flush: v });
      assert.strictEqual(await fsp.readFile(file, 'utf8'), data);
    }
  });
});