@zenfs/devel 0.0.1 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (105) hide show
  1. package/dist/bin/make-index.js +37 -74
  2. package/dist/bin/node-compat.d.ts +2 -0
  3. package/dist/bin/node-compat.js +337 -0
  4. package/dist/bin/zci.js +33 -44
  5. package/dist/bin/zenfs-test.js +48 -80
  6. package/dist/index.d.ts +1 -0
  7. package/dist/index.js +1 -0
  8. package/dist/make_index.d.ts +20 -0
  9. package/dist/make_index.js +49 -0
  10. package/dist/node_compat/analysis.d.ts +53 -0
  11. package/dist/node_compat/analysis.js +60 -0
  12. package/dist/node_compat/changelog.d.ts +25 -0
  13. package/dist/node_compat/changelog.js +60 -0
  14. package/dist/node_compat/commits.d.ts +26 -0
  15. package/dist/node_compat/commits.js +66 -0
  16. package/dist/node_compat/config.d.ts +6 -0
  17. package/dist/node_compat/config.js +18 -0
  18. package/dist/node_compat/docs.d.ts +58 -0
  19. package/dist/node_compat/docs.js +213 -0
  20. package/dist/node_compat/git.d.ts +22 -0
  21. package/dist/node_compat/git.js +74 -0
  22. package/dist/node_compat/index.d.ts +10 -0
  23. package/dist/node_compat/index.js +11 -0
  24. package/dist/node_compat/node.d.ts +42 -0
  25. package/dist/node_compat/node.js +84 -0
  26. package/dist/node_compat/output.d.ts +29 -0
  27. package/dist/node_compat/output.js +95 -0
  28. package/dist/node_compat/pr.d.ts +59 -0
  29. package/dist/node_compat/pr.js +125 -0
  30. package/dist/node_compat/state.d.ts +18 -0
  31. package/dist/node_compat/state.js +12 -0
  32. package/dist/node_compat/versions.d.ts +5 -0
  33. package/dist/node_compat/versions.js +13 -0
  34. package/dist/node_compat/zenfs.d.ts +3 -0
  35. package/dist/node_compat/zenfs.js +108 -0
  36. package/dist/tests/common.js +1 -1
  37. package/dist/tests/fs/append.test.d.ts +1 -0
  38. package/dist/tests/fs/append.test.js +27 -0
  39. package/dist/tests/fs/concurrency.test.d.ts +1 -0
  40. package/dist/tests/fs/concurrency.test.js +76 -0
  41. package/dist/tests/fs/dir.test.d.ts +1 -0
  42. package/dist/tests/fs/dir.test.js +83 -0
  43. package/dist/tests/fs/directory.test.d.ts +1 -0
  44. package/dist/tests/fs/directory.test.js +151 -0
  45. package/dist/tests/fs/errors.test.d.ts +1 -0
  46. package/dist/tests/fs/errors.test.js +141 -0
  47. package/dist/tests/fs/exists.test.d.ts +1 -0
  48. package/dist/tests/fs/exists.test.js +19 -0
  49. package/dist/tests/fs/links.test.d.ts +1 -0
  50. package/dist/tests/fs/links.test.js +248 -0
  51. package/dist/tests/fs/open.test.d.ts +1 -0
  52. package/dist/tests/fs/open.test.js +95 -0
  53. package/dist/tests/fs/permissions.test.d.ts +1 -0
  54. package/dist/tests/fs/permissions.test.js +346 -0
  55. package/dist/tests/fs/read.test.d.ts +1 -0
  56. package/dist/tests/fs/read.test.js +149 -0
  57. package/dist/tests/fs/readFile.test.d.ts +1 -0
  58. package/dist/tests/fs/readFile.test.js +110 -0
  59. package/dist/tests/fs/rename.test.d.ts +1 -0
  60. package/dist/tests/fs/rename.test.js +70 -0
  61. package/dist/tests/fs/scaling.test.d.ts +1 -0
  62. package/dist/tests/fs/scaling.test.js +27 -0
  63. package/dist/tests/fs/stat.test.d.ts +1 -0
  64. package/dist/tests/fs/stat.test.js +93 -0
  65. package/dist/tests/fs/streams.test.d.ts +1 -0
  66. package/dist/tests/fs/streams.test.js +161 -0
  67. package/dist/tests/fs/tempdir.test.d.ts +1 -0
  68. package/dist/tests/fs/tempdir.test.js +118 -0
  69. package/dist/tests/fs/times.test.d.ts +7 -0
  70. package/dist/tests/fs/times.test.js +134 -0
  71. package/dist/tests/fs/truncate.test.d.ts +1 -0
  72. package/dist/tests/fs/truncate.test.js +62 -0
  73. package/dist/tests/fs/watch.test.d.ts +1 -0
  74. package/dist/tests/fs/watch.test.js +320 -0
  75. package/dist/tests/fs/write.test.d.ts +1 -0
  76. package/dist/tests/fs/write.test.js +83 -0
  77. package/dist/tests/fs/xattr.test.d.ts +1 -0
  78. package/dist/tests/fs/xattr.test.js +137 -0
  79. package/dist/tests/setup/memory.d.ts +1 -0
  80. package/dist/tests/setup/memory.js +3 -0
  81. package/package.json +11 -6
  82. package/tests/readme.md +2 -2
  83. package/tests/fs/append.test.ts +0 -34
  84. package/tests/fs/concurrency.test.ts +0 -113
  85. package/tests/fs/dir.test.ts +0 -103
  86. package/tests/fs/directory.test.ts +0 -189
  87. package/tests/fs/errors.test.ts +0 -159
  88. package/tests/fs/exists.test.ts +0 -23
  89. package/tests/fs/links.test.ts +0 -308
  90. package/tests/fs/open.test.ts +0 -23
  91. package/tests/fs/permissions.test.ts +0 -344
  92. package/tests/fs/read.test.ts +0 -94
  93. package/tests/fs/readFile.test.ts +0 -58
  94. package/tests/fs/rename.test.ts +0 -93
  95. package/tests/fs/scaling.test.ts +0 -35
  96. package/tests/fs/stat.test.ts +0 -115
  97. package/tests/fs/streams.test.ts +0 -204
  98. package/tests/fs/tempdir.test.ts +0 -64
  99. package/tests/fs/times.test.ts +0 -85
  100. package/tests/fs/truncate.test.ts +0 -89
  101. package/tests/fs/watch.test.ts +0 -246
  102. package/tests/fs/write.test.ts +0 -118
  103. package/tests/fs/xattr.test.ts +0 -96
  104. package/tests/setup/memory.ts +0 -3
  105. package/tests/tsconfig.json +0 -8
@@ -1,23 +0,0 @@
1
- // SPDX-License-Identifier: LGPL-3.0-or-later
2
- import assert from 'node:assert/strict';
3
- import { suite, test } from 'node:test';
4
- import { config, fs } from '@zenfs/devel/tests/common';
5
-
6
- suite('exists', () => {
7
- const f = 'x.txt';
8
-
9
- test('return true for an existing file', config('async', 'promises.exists'), async () => {
10
- const exists = await fs.promises.exists(f);
11
- assert(exists);
12
- });
13
-
14
- test('return false for a non-existent file', config('async', 'promises.exists'), async () => {
15
- const exists = await fs.promises.exists(f + '-NO');
16
- assert(!exists);
17
- });
18
-
19
- test('have sync methods that behave the same', config('sync'), () => {
20
- assert(fs.existsSync(f));
21
- assert(!fs.existsSync(f + '-NO'));
22
- });
23
- });
@@ -1,308 +0,0 @@
1
- // SPDX-License-Identifier: LGPL-3.0-or-later
2
- import { join } from '@zenfs/core/path';
3
- import assert from 'node:assert/strict';
4
- import { suite, test } from 'node:test';
5
- import { config, fs } from '@zenfs/devel/tests/common';
6
-
7
- suite('Links', config('symlinks'), () => {
8
- const target = '/a1.js',
9
- symlink = 'symlink1.js',
10
- hardlink = 'link1.js';
11
-
12
- test('symlink', async () => {
13
- await fs.promises.symlink(target, symlink);
14
- });
15
-
16
- test('lstat', async () => {
17
- const stats = await fs.promises.lstat(symlink);
18
- assert(stats.isSymbolicLink());
19
- });
20
-
21
- test('symlinks have mode 0o777 #326', async () => {
22
- assert.equal((await fs.promises.lstat(symlink)).mode & 0o7777, 0o777);
23
-
24
- fs.symlinkSync(target, 'symlink-sync.js');
25
- const stats = fs.lstatSync('symlink-sync.js');
26
- assert(stats.isSymbolicLink());
27
- assert.equal(stats.mode & 0o7777, 0o777);
28
- fs.unlinkSync('symlink-sync.js');
29
- });
30
-
31
- test('lstat file inside symlinked directory #241', async () => {
32
- await fs.promises.mkdir('/a');
33
- await fs.promises.writeFile('/a/hello.txt', 'hello world');
34
- await fs.promises.symlink('/a', '/b');
35
-
36
- const stat = await fs.promises.lstat('/b/hello.txt');
37
- assert(stat.isFile());
38
- });
39
-
40
- test('readlink', async () => {
41
- const destination = await fs.promises.readlink(symlink);
42
- assert.equal(destination, target);
43
- assert.throws(() => fs.readlinkSync(destination));
44
- });
45
-
46
- test('read target contents', async () => {
47
- assert.equal(await fs.promises.readFile(target, 'utf-8'), await fs.promises.readFile(symlink, 'utf-8'));
48
- });
49
-
50
- test('nested symlinks', async () => {
51
- // Create the real directory structure
52
- const realDir = '/real-dir';
53
- const realFile = '/real-dir/realfile.txt';
54
- const fileContent = 'hello world';
55
- await fs.promises.mkdir(realDir);
56
- await fs.promises.writeFile(realFile, fileContent);
57
- // Create first symlink (symlink-dir -> real-dir)
58
- const symlinkDir = '/symlink-dir';
59
- await fs.promises.symlink(realDir, symlinkDir);
60
- const symfile = 'symfile.txt';
61
- const symlinkFile = join(realDir, symfile);
62
- // Create second symlink (symlink-dir -> real-dir)
63
- await fs.promises.symlink(realFile, symlinkFile);
64
- // Now access file through nested symlinks
65
- const nestedPath = join(symlinkDir, symfile);
66
- // Verify realpath resolution
67
- const resolvedPath = await fs.promises.realpath(nestedPath);
68
- assert.equal(resolvedPath, realFile);
69
- // Verify content can be read through nested symlinks
70
- const content = await fs.promises.readFile(nestedPath, 'utf8');
71
- assert.notEqual(content, '/real-dir/realfile.txt');
72
- assert.equal(content, fileContent);
73
- });
74
-
75
- test('unlink', async () => {
76
- await fs.promises.unlink(symlink);
77
- assert(!(await fs.promises.stat(symlink, { throwIfNoEntry: false })));
78
- assert(await fs.promises.stat(target, { throwIfNoEntry: false }));
79
- });
80
-
81
- test('link', config('links'), async () => {
82
- await fs.promises.link(target, hardlink);
83
- const targetContent = await fs.promises.readFile(target, 'utf8');
84
- const linkContent = await fs.promises.readFile(hardlink, 'utf8');
85
- assert.equal(targetContent, linkContent);
86
- });
87
-
88
- test('file inside symlinked directory', async () => {
89
- await fs.promises.symlink('.', 'link');
90
- const targetContent = await fs.promises.readFile(target, 'utf8');
91
- const link = join('link', target);
92
- assert((await fs.promises.realpath(link)) === target);
93
- const linkContent = await fs.promises.readFile(link, 'utf8');
94
- assert.equal(targetContent, linkContent);
95
- });
96
-
97
- test('mkdir does not follow a symlink at the final component', config('async'), async () => {
98
- await fs.promises.mkdir('/mkdir-real');
99
- await fs.promises.symlink('/mkdir-real', '/mkdir-link');
100
- await fs.promises.writeFile('/mkdir-file', 'contents');
101
- await fs.promises.symlink('/mkdir-file', '/mkdir-flink');
102
- await fs.promises.symlink('/mkdir-missing', '/mkdir-dangling');
103
-
104
- await assert.rejects(fs.promises.mkdir('/mkdir-link'), { code: 'EEXIST' });
105
- await assert.rejects(fs.promises.mkdir('/mkdir-dangling'), { code: 'EEXIST' });
106
- await assert.rejects(fs.promises.mkdir('/mkdir-flink', { recursive: true }), { code: 'EEXIST' });
107
- await assert.rejects(fs.promises.mkdir('/mkdir-dangling', { recursive: true }), { code: 'ENOENT' });
108
-
109
- // A link pointing at a directory satisfies a recursive mkdir and is left as a link
110
- assert.equal(await fs.promises.mkdir('/mkdir-link', { recursive: true }), undefined);
111
- assert((await fs.promises.lstat('/mkdir-link')).isSymbolicLink());
112
- assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
113
- });
114
-
115
- test('mkdir follows symlinks for intermediate components', config('async'), async () => {
116
- assert.equal(await fs.promises.mkdir('/mkdir-link/direct'), undefined);
117
- assert.equal(await fs.promises.mkdir('/mkdir-link/nested/deep', { recursive: true }), '/mkdir-link/nested');
118
-
119
- assert.deepEqual((await fs.promises.readdir('/mkdir-real')).sort(), ['direct', 'nested']);
120
- assert((await fs.promises.stat('/mkdir-real/nested/deep')).isDirectory());
121
-
122
- await assert.rejects(fs.promises.mkdir('/mkdir-flink/x', { recursive: true }), { code: 'ENOTDIR' });
123
-
124
- // Node reports the link itself here, unlike `mkdirSync` which reports the requested path with ENOENT
125
- await assert.rejects(fs.promises.mkdir('/mkdir-dangling/x', { recursive: true }), { code: 'ENOTDIR', path: '/mkdir-dangling' });
126
- assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
127
- });
128
-
129
- test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {
130
- fs.mkdirSync('/mkdirS-real');
131
- fs.symlinkSync('/mkdirS-real', '/mkdirS-link');
132
- fs.writeFileSync('/mkdirS-file', 'contents');
133
- fs.symlinkSync('/mkdirS-file', '/mkdirS-flink');
134
- fs.symlinkSync('/mkdirS-missing', '/mkdirS-dangling');
135
-
136
- assert.throws(() => fs.mkdirSync('/mkdirS-link'), { code: 'EEXIST' });
137
- assert.throws(() => fs.mkdirSync('/mkdirS-dangling'), { code: 'EEXIST' });
138
- assert.throws(() => fs.mkdirSync('/mkdirS-flink', { recursive: true }), { code: 'EEXIST' });
139
- assert.throws(() => fs.mkdirSync('/mkdirS-dangling', { recursive: true }), { code: 'ENOENT' });
140
-
141
- assert.equal(fs.mkdirSync('/mkdirS-link', { recursive: true }), undefined);
142
- assert(fs.lstatSync('/mkdirS-link').isSymbolicLink());
143
- assert(!fs.existsSync('/mkdirS-missing'));
144
- });
145
-
146
- test('mkdirSync follows symlinks for intermediate components', config('sync'), () => {
147
- assert.equal(fs.mkdirSync('/mkdirS-link/direct'), undefined);
148
- assert.equal(fs.mkdirSync('/mkdirS-link/nested/deep', { recursive: true }), '/mkdirS-link/nested');
149
-
150
- assert.deepEqual(fs.readdirSync('/mkdirS-real').sort(), ['direct', 'nested']);
151
- assert(fs.statSync('/mkdirS-real/nested/deep').isDirectory());
152
-
153
- assert.throws(() => fs.mkdirSync('/mkdirS-flink/x', { recursive: true }), { code: 'ENOTDIR' });
154
- assert.throws(() => fs.mkdirSync('/mkdirS-dangling/x', { recursive: true }), { code: 'ENOENT', path: '/mkdirS-dangling/x' });
155
- assert(!fs.existsSync('/mkdirS-missing'));
156
- });
157
-
158
- test('writeFile and appendFile follow symlinks', config('async'), async () => {
159
- await fs.promises.mkdir('/wf-real');
160
- await fs.promises.symlink('/wf-real', '/wf-link');
161
- await fs.promises.writeFile('/wf-real/f.txt', 'original');
162
- await fs.promises.symlink('/wf-real/f.txt', '/wf-flink');
163
- await fs.promises.symlink('/wf-missing.txt', '/wf-dangling');
164
-
165
- await fs.promises.writeFile('/wf-link/new.txt', 'hi');
166
- assert.equal(await fs.promises.readFile('/wf-real/new.txt', 'utf8'), 'hi');
167
-
168
- // A link to a file is written through, not replaced
169
- await fs.promises.writeFile('/wf-flink', 'replaced');
170
- await fs.promises.appendFile('/wf-flink', '+');
171
- assert.equal(await fs.promises.readFile('/wf-real/f.txt', 'utf8'), 'replaced+');
172
- assert((await fs.promises.lstat('/wf-flink')).isSymbolicLink());
173
-
174
- // Writing through a dangling link creates its target
175
- await fs.promises.writeFile('/wf-dangling', 'made');
176
- assert.equal(await fs.promises.readFile('/wf-missing.txt', 'utf8'), 'made');
177
- assert((await fs.promises.lstat('/wf-dangling')).isSymbolicLink());
178
- });
179
-
180
- test('writeFileSync and appendFileSync follow symlinks', config('sync'), () => {
181
- fs.mkdirSync('/wfS-real');
182
- fs.symlinkSync('/wfS-real', '/wfS-link');
183
- fs.writeFileSync('/wfS-real/f.txt', 'original');
184
- fs.symlinkSync('/wfS-real/f.txt', '/wfS-flink');
185
- fs.symlinkSync('/wfS-missing.txt', '/wfS-dangling');
186
-
187
- fs.writeFileSync('/wfS-link/new.txt', 'hi');
188
- assert.equal(fs.readFileSync('/wfS-real/new.txt', 'utf8'), 'hi');
189
-
190
- fs.writeFileSync('/wfS-flink', 'replaced');
191
- fs.appendFileSync('/wfS-flink', '+');
192
- assert.equal(fs.readFileSync('/wfS-real/f.txt', 'utf8'), 'replaced+');
193
- assert(fs.lstatSync('/wfS-flink').isSymbolicLink());
194
-
195
- fs.writeFileSync('/wfS-dangling', 'made');
196
- assert.equal(fs.readFileSync('/wfS-missing.txt', 'utf8'), 'made');
197
- assert(fs.lstatSync('/wfS-dangling').isSymbolicLink());
198
- });
199
-
200
- test('operations follow symlinks in parent directories', config('async'), async () => {
201
- await fs.promises.mkdir('/parent-real');
202
- await fs.promises.symlink('/parent-real', '/parent-link');
203
- await fs.promises.writeFile('/parent-real/unlink', 'x');
204
- await fs.promises.writeFile('/parent-real/rename', 'x');
205
- await fs.promises.mkdir('/parent-real/rmdir');
206
- await fs.promises.symlink('/parent-real/renamed', '/parent-real/symlink');
207
- await fs.promises.symlink('/parent-real/rmdir', '/parent-real/dir-link');
208
-
209
- await fs.promises.unlink('/parent-link/unlink');
210
- await fs.promises.rename('/parent-link/rename', '/parent-link/renamed');
211
- assert.equal(await fs.promises.readlink('/parent-link/symlink'), '/parent-real/renamed');
212
- await fs.promises.lutimes('/parent-link/symlink', 1, 1);
213
- assert.equal((await fs.promises.lstat('/parent-real/symlink')).mtimeMs, 1000);
214
-
215
- await assert.rejects(fs.promises.rmdir('/parent-link/dir-link'), { code: 'ENOTDIR' });
216
- await fs.promises.unlink('/parent-link/dir-link');
217
- await fs.promises.rmdir('/parent-link/rmdir');
218
-
219
- assert.deepEqual((await fs.promises.readdir('/parent-real')).sort(), ['renamed', 'symlink']);
220
- });
221
-
222
- test('operations follow symlinks in parent directories (sync)', config('sync'), () => {
223
- fs.mkdirSync('/parentS-real');
224
- fs.symlinkSync('/parentS-real', '/parentS-link');
225
- fs.writeFileSync('/parentS-real/unlink', 'x');
226
- fs.writeFileSync('/parentS-real/rename', 'x');
227
- fs.mkdirSync('/parentS-real/rmdir');
228
- fs.symlinkSync('/parentS-real/renamed', '/parentS-real/symlink');
229
- fs.symlinkSync('/parentS-real/rmdir', '/parentS-real/dir-link');
230
-
231
- fs.unlinkSync('/parentS-link/unlink');
232
- fs.renameSync('/parentS-link/rename', '/parentS-link/renamed');
233
- assert.equal(fs.readlinkSync('/parentS-link/symlink'), '/parentS-real/renamed');
234
- fs.lutimesSync('/parentS-link/symlink', 1, 1);
235
- assert.equal(fs.lstatSync('/parentS-real/symlink').mtimeMs, 1000);
236
-
237
- assert.throws(() => fs.rmdirSync('/parentS-link/dir-link'), { code: 'ENOTDIR' });
238
- fs.unlinkSync('/parentS-link/dir-link');
239
- fs.rmdirSync('/parentS-link/rmdir');
240
-
241
- assert.deepEqual(fs.readdirSync('/parentS-real').sort(), ['renamed', 'symlink']);
242
- });
243
-
244
- test('link follows symlinks in parent directories', config('links'), async () => {
245
- await fs.promises.link('/parent-link/renamed', '/parent-link/hard');
246
- assert.equal(await fs.promises.readFile('/parent-real/hard', 'utf8'), 'x');
247
- fs.linkSync('/parentS-link/renamed', '/parentS-link/hard');
248
- assert.equal(fs.readFileSync('/parentS-real/hard', 'utf8'), 'x');
249
- });
250
-
251
- test('xattr follows symlinks unless noFollow is set', config('xattr'), async () => {
252
- await fs.xattr.set('/parent-link/renamed', 'user.parent', 'async');
253
- assert.equal(await fs.xattr.get('/parent-real/renamed', 'user.parent', { encoding: 'utf8' }), 'async');
254
- fs.xattr.setSync('/parentS-link/renamed', 'user.parent', 'sync');
255
- assert.equal(fs.xattr.getSync('/parentS-real/renamed', 'user.parent', { encoding: 'utf8' }), 'sync');
256
-
257
- await fs.xattr.set('/parent-link/symlink', 'user.link', 'on link', { noFollow: true });
258
- assert.equal(await fs.xattr.get('/parent-real/symlink', 'user.link', { encoding: 'utf8', noFollow: true }), 'on link');
259
- await assert.rejects(fs.xattr.get('/parent-real/renamed', 'user.link'), { code: 'ENODATA' });
260
- assert.deepEqual(await fs.xattr.list('/parent-link/symlink'), ['user.parent']);
261
-
262
- await fs.xattr.remove('/parent-link/renamed', 'user.parent');
263
- assert.deepEqual(fs.xattr.listSync('/parent-real/renamed'), []);
264
- });
265
-
266
- test('cp preserves a symlink by default #304', async () => {
267
- await fs.promises.mkdir('/cp-src');
268
- await fs.promises.writeFile('/cp-src/real.txt', 'contents');
269
- await fs.promises.symlink('real.txt', '/cp-src/link.txt');
270
-
271
- await fs.promises.cp('/cp-src', '/cp-dst', { recursive: true });
272
-
273
- const stats = await fs.promises.lstat('/cp-dst/link.txt');
274
- assert(stats.isSymbolicLink());
275
-
276
- // A relative target is resolved against the link's directory, so the copy points at the original file
277
- assert.equal(await fs.promises.readlink('/cp-dst/link.txt'), '/cp-src/real.txt');
278
- });
279
-
280
- test('cp with verbatimSymlinks keeps the target unresolved', async () => {
281
- await fs.promises.cp('/cp-src', '/cp-verbatim', { recursive: true, verbatimSymlinks: true });
282
-
283
- assert((await fs.promises.lstat('/cp-verbatim/link.txt')).isSymbolicLink());
284
- assert.equal(await fs.promises.readlink('/cp-verbatim/link.txt'), 'real.txt');
285
- });
286
-
287
- test('cp with dereference copies the symlink target contents #304', async () => {
288
- await fs.promises.cp('/cp-src', '/cp-deref', { recursive: true, dereference: true });
289
-
290
- const stats = await fs.promises.lstat('/cp-deref/link.txt');
291
- assert(!stats.isSymbolicLink());
292
- assert.equal(await fs.promises.readFile('/cp-deref/link.txt', 'utf8'), 'contents');
293
- });
294
-
295
- test('cpSync preserves a symlink #304', () => {
296
- fs.writeFileSync('/cp-sync-target.txt', 'contents');
297
- fs.symlinkSync('cp-sync-target.txt', '/cp-sync-link');
298
-
299
- fs.cpSync('/cp-sync-link', '/cp-sync-link-copy');
300
-
301
- const stats = fs.lstatSync('/cp-sync-link-copy');
302
- assert(stats.isSymbolicLink());
303
- assert.equal(fs.readlinkSync('/cp-sync-link-copy'), '/cp-sync-target.txt');
304
-
305
- fs.cpSync('/cp-sync-link', '/cp-sync-link-verbatim', { verbatimSymlinks: true });
306
- assert.equal(fs.readlinkSync('/cp-sync-link-verbatim'), 'cp-sync-target.txt');
307
- });
308
- });
@@ -1,23 +0,0 @@
1
- // SPDX-License-Identifier: LGPL-3.0-or-later
2
- import assert from 'node:assert/strict';
3
- import { suite, test } from 'node:test';
4
- import { config, fs } from '@zenfs/devel/tests/common';
5
-
6
- suite('Opening files', () => {
7
- const filename = 'a.js';
8
-
9
- test('throw ENOENT when opening non-existent file', config('sync', 'async'), async () => {
10
- assert.throws(() => fs.openSync('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
11
- await assert.rejects(fs.promises.open('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
12
- });
13
-
14
- test('open file with mode "r"', config('async'), async () => {
15
- await using handle = await fs.promises.open(filename, 'r');
16
- assert(handle.fd >= -Infinity);
17
- });
18
-
19
- test('open file with mode "rs"', config('async'), async () => {
20
- await using handle = await fs.promises.open(filename, 'rs');
21
- assert(handle.fd >= -Infinity);
22
- });
23
- });