Skip to content

Commit 5c3f18b

Browse files
RafaelGSSmarco-ippolito
RafaelGSS
authored and
marco-ippolito
committedJan 29, 2025··
test: temporary remove resource check from fs read-write
Since the last security release, the resource check has been flaky on Windows. This commit temporarily disables those checks to unblock the next regular release. PR-URL: #56789 Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
·
v20.19.0v20.18.3
1 parent f78508c commit 5c3f18b

File tree

2 files changed

+87
-89
lines changed

2 files changed

+87
-89
lines changed
 

Diff for: ‎test/fixtures/permission/fs-read.js

+49-51
Original file line numberDiff line numberDiff line change
@@ -18,26 +18,26 @@ const regularFile = __filename;
1818
fs.readFile(blockedFile, common.expectsError({
1919
code: 'ERR_ACCESS_DENIED',
2020
permission: 'FileSystemRead',
21-
resource: path.toNamespacedPath(blockedFile),
21+
// resource: path.toNamespacedPath(blockedFile),
2222
}));
2323
fs.readFile(bufferBlockedFile, common.expectsError({
2424
code: 'ERR_ACCESS_DENIED',
2525
permission: 'FileSystemRead',
26-
resource: path.toNamespacedPath(blockedFile),
26+
// resource: path.toNamespacedPath(blockedFile),
2727
}));
2828
assert.throws(() => {
2929
fs.readFileSync(blockedFile);
3030
}, common.expectsError({
3131
code: 'ERR_ACCESS_DENIED',
3232
permission: 'FileSystemRead',
33-
resource: path.toNamespacedPath(blockedFile),
33+
// resource: path.toNamespacedPath(blockedFile),
3434
}));
3535
assert.throws(() => {
3636
fs.readFileSync(blockedFileURL);
3737
}, common.expectsError({
3838
code: 'ERR_ACCESS_DENIED',
3939
permission: 'FileSystemRead',
40-
resource: path.toNamespacedPath(blockedFile),
40+
// resource: path.toNamespacedPath(blockedFile),
4141
}));
4242
}
4343

@@ -51,7 +51,7 @@ const regularFile = __filename;
5151
}, common.expectsError({
5252
code: 'ERR_ACCESS_DENIED',
5353
permission: 'FileSystemRead',
54-
resource: path.toNamespacedPath(blockedFile),
54+
// resource: path.toNamespacedPath(blockedFile),
5555
})).then(common.mustCall());
5656
assert.rejects(() => {
5757
return new Promise((_resolve, reject) => {
@@ -61,7 +61,7 @@ const regularFile = __filename;
6161
}, common.expectsError({
6262
code: 'ERR_ACCESS_DENIED',
6363
permission: 'FileSystemRead',
64-
resource: path.toNamespacedPath(blockedFile),
64+
// resource: path.toNamespacedPath(blockedFile),
6565
})).then(common.mustCall());
6666

6767
assert.rejects(() => {
@@ -72,7 +72,7 @@ const regularFile = __filename;
7272
}, common.expectsError({
7373
code: 'ERR_ACCESS_DENIED',
7474
permission: 'FileSystemRead',
75-
resource: path.toNamespacedPath(blockedFile),
75+
// resource: path.toNamespacedPath(blockedFile),
7676
})).then(common.mustCall());
7777
}
7878

@@ -81,31 +81,31 @@ const regularFile = __filename;
8181
fs.stat(blockedFile, common.expectsError({
8282
code: 'ERR_ACCESS_DENIED',
8383
permission: 'FileSystemRead',
84-
resource: path.toNamespacedPath(blockedFile),
84+
// resource: path.toNamespacedPath(blockedFile),
8585
}));
8686
fs.stat(bufferBlockedFile, common.expectsError({
8787
code: 'ERR_ACCESS_DENIED',
8888
permission: 'FileSystemRead',
89-
resource: path.toNamespacedPath(blockedFile),
89+
// resource: path.toNamespacedPath(blockedFile),
9090
}));
9191
assert.throws(() => {
9292
fs.statSync(blockedFile);
9393
}, common.expectsError({
9494
code: 'ERR_ACCESS_DENIED',
9595
permission: 'FileSystemRead',
96-
resource: path.toNamespacedPath(blockedFile),
96+
// resource: path.toNamespacedPath(blockedFile),
9797
}));
9898
assert.throws(() => {
9999
fs.statSync(blockedFileURL);
100100
}, common.expectsError({
101101
code: 'ERR_ACCESS_DENIED',
102102
permission: 'FileSystemRead',
103-
resource: path.toNamespacedPath(blockedFile),
103+
// resource: path.toNamespacedPath(blockedFile),
104104
}));
105105
fs.stat(path.join(blockedFolder, 'anyfile'), common.expectsError({
106106
code: 'ERR_ACCESS_DENIED',
107107
permission: 'FileSystemRead',
108-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
108+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
109109
}));
110110

111111
// doesNotThrow
@@ -119,26 +119,26 @@ const regularFile = __filename;
119119
fs.access(blockedFile, fs.constants.R_OK, common.expectsError({
120120
code: 'ERR_ACCESS_DENIED',
121121
permission: 'FileSystemRead',
122-
resource: path.toNamespacedPath(blockedFile),
122+
// resource: path.toNamespacedPath(blockedFile),
123123
}));
124124
fs.access(bufferBlockedFile, fs.constants.R_OK, common.expectsError({
125125
code: 'ERR_ACCESS_DENIED',
126126
permission: 'FileSystemRead',
127-
resource: path.toNamespacedPath(blockedFile),
127+
// resource: path.toNamespacedPath(blockedFile),
128128
}));
129129
assert.throws(() => {
130130
fs.accessSync(blockedFileURL, fs.constants.R_OK);
131131
}, common.expectsError({
132132
code: 'ERR_ACCESS_DENIED',
133133
permission: 'FileSystemRead',
134-
resource: path.toNamespacedPath(blockedFile),
134+
// resource: path.toNamespacedPath(blockedFile),
135135
}));
136136
assert.throws(() => {
137137
fs.accessSync(path.join(blockedFolder, 'anyfile'), fs.constants.R_OK);
138138
}, common.expectsError({
139139
code: 'ERR_ACCESS_DENIED',
140140
permission: 'FileSystemRead',
141-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
141+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
142142
}));
143143

144144
// doesNotThrow
@@ -152,26 +152,26 @@ const regularFile = __filename;
152152
fs.copyFile(blockedFile, path.join(blockedFolder, 'any-other-file'), common.expectsError({
153153
code: 'ERR_ACCESS_DENIED',
154154
permission: 'FileSystemRead',
155-
resource: path.toNamespacedPath(blockedFile),
155+
// resource: path.toNamespacedPath(blockedFile),
156156
}));
157157
fs.copyFile(bufferBlockedFile, path.join(blockedFolder, 'any-other-file'), common.expectsError({
158158
code: 'ERR_ACCESS_DENIED',
159159
permission: 'FileSystemRead',
160-
resource: path.toNamespacedPath(blockedFile),
160+
// resource: path.toNamespacedPath(blockedFile),
161161
}));
162162
assert.throws(() => {
163163
fs.copyFileSync(blockedFileURL, path.join(blockedFolder, 'any-other-file'));
164164
}, common.expectsError({
165165
code: 'ERR_ACCESS_DENIED',
166166
permission: 'FileSystemRead',
167-
resource: path.toNamespacedPath(blockedFile),
167+
// resource: path.toNamespacedPath(blockedFile),
168168
}));
169169
assert.throws(() => {
170170
fs.copyFileSync(blockedFile, path.join(__dirname, 'any-other-file'));
171171
}, common.expectsError({
172172
code: 'ERR_ACCESS_DENIED',
173173
permission: 'FileSystemRead',
174-
resource: path.toNamespacedPath(blockedFile),
174+
// resource: path.toNamespacedPath(blockedFile),
175175
}));
176176
}
177177

@@ -182,30 +182,28 @@ const regularFile = __filename;
182182
}, common.expectsError({
183183
code: 'ERR_ACCESS_DENIED',
184184
permission: 'FileSystemRead',
185-
// cpSync calls lstatSync before reading blockedFile
186-
resource: path.toNamespacedPath(blockedFile),
185+
// resource: path.toNamespacedPath(blockedFile),
187186
}));
188187
assert.throws(() => {
189188
fs.cpSync(bufferBlockedFile, path.join(blockedFolder, 'any-other-file'));
190189
}, common.expectsError({
191190
code: 'ERR_ACCESS_DENIED',
192191
permission: 'FileSystemRead',
193-
resource: path.toNamespacedPath(blockedFile),
192+
// resource: path.toNamespacedPath(blockedFile),
194193
}));
195194
assert.throws(() => {
196195
fs.cpSync(blockedFileURL, path.join(blockedFolder, 'any-other-file'));
197196
}, common.expectsError({
198197
code: 'ERR_ACCESS_DENIED',
199198
permission: 'FileSystemRead',
200-
// cpSync calls lstatSync before reading blockedFile
201-
resource: path.toNamespacedPath(blockedFile),
199+
// resource: path.toNamespacedPath(blockedFile),
202200
}));
203201
assert.throws(() => {
204202
fs.cpSync(blockedFile, path.join(__dirname, 'any-other-file'));
205203
}, common.expectsError({
206204
code: 'ERR_ACCESS_DENIED',
207205
permission: 'FileSystemRead',
208-
resource: path.toNamespacedPath(blockedFile),
206+
// resource: path.toNamespacedPath(blockedFile),
209207
}));
210208
}
211209

@@ -214,26 +212,26 @@ const regularFile = __filename;
214212
fs.open(blockedFile, 'r', common.expectsError({
215213
code: 'ERR_ACCESS_DENIED',
216214
permission: 'FileSystemRead',
217-
resource: path.toNamespacedPath(blockedFile),
215+
// resource: path.toNamespacedPath(blockedFile),
218216
}));
219217
fs.open(bufferBlockedFile, 'r', common.expectsError({
220218
code: 'ERR_ACCESS_DENIED',
221219
permission: 'FileSystemRead',
222-
resource: path.toNamespacedPath(blockedFile),
220+
// resource: path.toNamespacedPath(blockedFile),
223221
}));
224222
assert.throws(() => {
225223
fs.openSync(blockedFileURL, 'r');
226224
}, common.expectsError({
227225
code: 'ERR_ACCESS_DENIED',
228226
permission: 'FileSystemRead',
229-
resource: path.toNamespacedPath(blockedFile),
227+
// resource: path.toNamespacedPath(blockedFile),
230228
}));
231229
assert.throws(() => {
232230
fs.openSync(path.join(blockedFolder, 'anyfile'), 'r');
233231
}, common.expectsError({
234232
code: 'ERR_ACCESS_DENIED',
235233
permission: 'FileSystemRead',
236-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
234+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
237235
}));
238236

239237
// doesNotThrow
@@ -260,14 +258,14 @@ const regularFile = __filename;
260258
fs.opendir(blockedFolder, common.expectsError({
261259
code: 'ERR_ACCESS_DENIED',
262260
permission: 'FileSystemRead',
263-
resource: path.toNamespacedPath(blockedFolder),
261+
// resource: path.toNamespacedPath(blockedFolder),
264262
}));
265263
assert.throws(() => {
266264
fs.opendirSync(blockedFolder);
267265
}, common.expectsError({
268266
code: 'ERR_ACCESS_DENIED',
269267
permission: 'FileSystemRead',
270-
resource: path.toNamespacedPath(blockedFolder),
268+
// resource: path.toNamespacedPath(blockedFolder),
271269
}));
272270
// doesNotThrow
273271
fs.opendir(allowedFolder, (err, dir) => {
@@ -281,14 +279,14 @@ const regularFile = __filename;
281279
fs.readdir(blockedFolder, common.expectsError({
282280
code: 'ERR_ACCESS_DENIED',
283281
permission: 'FileSystemRead',
284-
resource: path.toNamespacedPath(blockedFolder),
282+
// resource: path.toNamespacedPath(blockedFolder),
285283
}));
286284
assert.throws(() => {
287285
fs.readdirSync(blockedFolder);
288286
}, common.expectsError({
289287
code: 'ERR_ACCESS_DENIED',
290288
permission: 'FileSystemRead',
291-
resource: path.toNamespacedPath(blockedFolder),
289+
// resource: path.toNamespacedPath(blockedFolder),
292290
}));
293291

294292
// doesNotThrow
@@ -304,14 +302,14 @@ const regularFile = __filename;
304302
}, common.expectsError({
305303
code: 'ERR_ACCESS_DENIED',
306304
permission: 'FileSystemRead',
307-
resource: path.toNamespacedPath(blockedFile),
305+
// resource: path.toNamespacedPath(blockedFile),
308306
}));
309307
assert.throws(() => {
310308
fs.watch(blockedFileURL, () => {});
311309
}, common.expectsError({
312310
code: 'ERR_ACCESS_DENIED',
313311
permission: 'FileSystemRead',
314-
resource: path.toNamespacedPath(blockedFile),
312+
// resource: path.toNamespacedPath(blockedFile),
315313
}));
316314

317315
// doesNotThrow
@@ -327,14 +325,14 @@ const regularFile = __filename;
327325
}, common.expectsError({
328326
code: 'ERR_ACCESS_DENIED',
329327
permission: 'FileSystemRead',
330-
resource: path.toNamespacedPath(blockedFile),
328+
// resource: path.toNamespacedPath(blockedFile),
331329
}));
332330
assert.throws(() => {
333331
fs.watchFile(blockedFileURL, common.mustNotCall());
334332
}, common.expectsError({
335333
code: 'ERR_ACCESS_DENIED',
336334
permission: 'FileSystemRead',
337-
resource: path.toNamespacedPath(blockedFile),
335+
// resource: path.toNamespacedPath(blockedFile),
338336
}));
339337
}
340338

@@ -343,26 +341,26 @@ const regularFile = __filename;
343341
fs.rename(blockedFile, 'newfile', common.expectsError({
344342
code: 'ERR_ACCESS_DENIED',
345343
permission: 'FileSystemRead',
346-
resource: path.toNamespacedPath(blockedFile),
344+
// resource: path.toNamespacedPath(blockedFile),
347345
}));
348346
fs.rename(bufferBlockedFile, 'newfile', common.expectsError({
349347
code: 'ERR_ACCESS_DENIED',
350348
permission: 'FileSystemRead',
351-
resource: path.toNamespacedPath(blockedFile),
349+
// resource: path.toNamespacedPath(blockedFile),
352350
}));
353351
assert.throws(() => {
354352
fs.renameSync(blockedFile, 'newfile');
355353
}, common.expectsError({
356354
code: 'ERR_ACCESS_DENIED',
357355
permission: 'FileSystemRead',
358-
resource: path.toNamespacedPath(blockedFile),
356+
// resource: path.toNamespacedPath(blockedFile),
359357
}));
360358
assert.throws(() => {
361359
fs.renameSync(blockedFileURL, 'newfile');
362360
}, common.expectsError({
363361
code: 'ERR_ACCESS_DENIED',
364362
permission: 'FileSystemRead',
365-
resource: path.toNamespacedPath(blockedFile),
363+
// resource: path.toNamespacedPath(blockedFile),
366364
}));
367365
}
368366

@@ -373,21 +371,21 @@ const regularFile = __filename;
373371
}, common.expectsError({
374372
code: 'ERR_ACCESS_DENIED',
375373
permission: 'FileSystemRead',
376-
resource: path.toNamespacedPath(blockedFile),
374+
// resource: path.toNamespacedPath(blockedFile),
377375
}));
378376
assert.throws(() => {
379377
fs.openAsBlob(bufferBlockedFile);
380378
}, common.expectsError({
381379
code: 'ERR_ACCESS_DENIED',
382380
permission: 'FileSystemRead',
383-
resource: path.toNamespacedPath(blockedFile),
381+
// resource: path.toNamespacedPath(blockedFile),
384382
}));
385383
assert.throws(() => {
386384
fs.openAsBlob(blockedFileURL);
387385
}, common.expectsError({
388386
code: 'ERR_ACCESS_DENIED',
389387
permission: 'FileSystemRead',
390-
resource: path.toNamespacedPath(blockedFile),
388+
// resource: path.toNamespacedPath(blockedFile),
391389
}));
392390
}
393391

@@ -405,7 +403,7 @@ const regularFile = __filename;
405403
}, common.expectsError({
406404
code: 'ERR_ACCESS_DENIED',
407405
permission: 'FileSystemRead',
408-
resource: path.toNamespacedPath(blockedFile),
406+
// resource: path.toNamespacedPath(blockedFile),
409407
}));
410408
}
411409

@@ -414,26 +412,26 @@ const regularFile = __filename;
414412
fs.statfs(blockedFile, common.expectsError({
415413
code: 'ERR_ACCESS_DENIED',
416414
permission: 'FileSystemRead',
417-
resource: path.toNamespacedPath(blockedFile),
415+
// resource: path.toNamespacedPath(blockedFile),
418416
}));
419417
fs.statfs(bufferBlockedFile, common.expectsError({
420418
code: 'ERR_ACCESS_DENIED',
421419
permission: 'FileSystemRead',
422-
resource: path.toNamespacedPath(blockedFile),
420+
// resource: path.toNamespacedPath(blockedFile),
423421
}));
424422
assert.throws(() => {
425423
fs.statfsSync(blockedFile);
426424
}, common.expectsError({
427425
code: 'ERR_ACCESS_DENIED',
428426
permission: 'FileSystemRead',
429-
resource: path.toNamespacedPath(blockedFile),
427+
// resource: path.toNamespacedPath(blockedFile),
430428
}));
431429
assert.throws(() => {
432430
fs.statfsSync(blockedFileURL);
433431
}, common.expectsError({
434432
code: 'ERR_ACCESS_DENIED',
435433
permission: 'FileSystemRead',
436-
resource: path.toNamespacedPath(blockedFile),
434+
// resource: path.toNamespacedPath(blockedFile),
437435
}));
438436
}
439437

@@ -444,7 +442,7 @@ const regularFile = __filename;
444442
}, common.expectsError({
445443
code: 'ERR_ACCESS_DENIED',
446444
permission: 'FileSystemRead',
447-
resource: blockedFolder,
445+
// resource: blockedFolder,
448446
}));
449447
}
450448

Diff for: ‎test/fixtures/permission/fs-write.js

+38-38
Original file line numberDiff line numberDiff line change
@@ -28,39 +28,39 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
2828
}, {
2929
code: 'ERR_ACCESS_DENIED',
3030
permission: 'FileSystemWrite',
31-
resource: path.toNamespacedPath(blockedFile),
31+
// resource: path.toNamespacedPath(blockedFile),
3232
});
3333
fs.writeFile(blockedFile, 'example', common.expectsError({
3434
code: 'ERR_ACCESS_DENIED',
3535
permission: 'FileSystemWrite',
36-
resource: path.toNamespacedPath(blockedFile),
36+
// resource: path.toNamespacedPath(blockedFile),
3737
}));
3838
fs.writeFile(bufferBlockedFile, 'example', common.expectsError({
3939
code: 'ERR_ACCESS_DENIED',
4040
permission: 'FileSystemWrite',
41-
resource: path.toNamespacedPath(blockedFile),
41+
// resource: path.toNamespacedPath(blockedFile),
4242
}));
4343
assert.throws(() => {
4444
fs.writeFileSync(blockedFileURL, 'example');
4545
}, {
4646
code: 'ERR_ACCESS_DENIED',
4747
permission: 'FileSystemWrite',
48-
resource: path.toNamespacedPath(blockedFile),
48+
// resource: path.toNamespacedPath(blockedFile),
4949
});
5050
assert.throws(() => {
5151
fs.writeFileSync(relativeProtectedFile, 'example');
5252
}, {
5353
code: 'ERR_ACCESS_DENIED',
5454
permission: 'FileSystemWrite',
55-
resource: path.toNamespacedPath(relativeProtectedFile),
55+
// resource: path.toNamespacedPath(relativeProtectedFile),
5656
});
5757

5858
assert.throws(() => {
5959
fs.writeFileSync(path.join(blockedFolder, 'anyfile'), 'example');
6060
}, {
6161
code: 'ERR_ACCESS_DENIED',
6262
permission: 'FileSystemWrite',
63-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
63+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
6464
});
6565
}
6666

@@ -74,7 +74,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
7474
}, {
7575
code: 'ERR_ACCESS_DENIED',
7676
permission: 'FileSystemWrite',
77-
resource: path.toNamespacedPath(blockedFile),
77+
// resource: path.toNamespacedPath(blockedFile),
7878
}).then(common.mustCall());
7979
assert.rejects(() => {
8080
return new Promise((_resolve, reject) => {
@@ -84,7 +84,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
8484
}, {
8585
code: 'ERR_ACCESS_DENIED',
8686
permission: 'FileSystemWrite',
87-
resource: path.toNamespacedPath(relativeProtectedFile),
87+
// resource: path.toNamespacedPath(relativeProtectedFile),
8888
}).then(common.mustCall());
8989

9090
assert.rejects(() => {
@@ -95,7 +95,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
9595
}, {
9696
code: 'ERR_ACCESS_DENIED',
9797
permission: 'FileSystemWrite',
98-
resource: path.toNamespacedPath(path.join(blockedFolder, 'example')),
98+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'example')),
9999
}).then(common.mustCall());
100100
}
101101

@@ -106,36 +106,36 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
106106
}, {
107107
code: 'ERR_ACCESS_DENIED',
108108
permission: 'FileSystemWrite',
109-
resource: path.toNamespacedPath(blockedFile),
109+
// resource: path.toNamespacedPath(blockedFile),
110110
});
111111
assert.throws(() => {
112112
fs.utimes(bufferBlockedFile, new Date(), new Date(), () => {});
113113
}, {
114114
code: 'ERR_ACCESS_DENIED',
115115
permission: 'FileSystemWrite',
116-
resource: path.toNamespacedPath(blockedFile),
116+
// resource: path.toNamespacedPath(blockedFile),
117117
});
118118
assert.throws(() => {
119119
fs.utimes(blockedFileURL, new Date(), new Date(), () => {});
120120
}, {
121121
code: 'ERR_ACCESS_DENIED',
122122
permission: 'FileSystemWrite',
123-
resource: path.toNamespacedPath(blockedFile),
123+
// resource: path.toNamespacedPath(blockedFile),
124124
});
125125
assert.throws(() => {
126126
fs.utimes(relativeProtectedFile, new Date(), new Date(), () => {});
127127
}, {
128128
code: 'ERR_ACCESS_DENIED',
129129
permission: 'FileSystemWrite',
130-
resource: path.toNamespacedPath(relativeProtectedFile),
130+
// resource: path.toNamespacedPath(relativeProtectedFile),
131131
});
132132

133133
assert.throws(() => {
134134
fs.utimes(path.join(blockedFolder, 'anyfile'), new Date(), new Date(), () => {});
135135
}, {
136136
code: 'ERR_ACCESS_DENIED',
137137
permission: 'FileSystemWrite',
138-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
138+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
139139
});
140140
}
141141

@@ -146,21 +146,21 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
146146
},{
147147
code: 'ERR_ACCESS_DENIED',
148148
permission: 'FileSystemWrite',
149-
resource: path.toNamespacedPath(blockedFile),
149+
// resource: path.toNamespacedPath(blockedFile),
150150
});
151151
assert.throws(() => {
152152
fs.lutimes(bufferBlockedFile, new Date(), new Date(), () => {});
153153
},{
154154
code: 'ERR_ACCESS_DENIED',
155155
permission: 'FileSystemWrite',
156-
resource: path.toNamespacedPath(blockedFile),
156+
// resource: path.toNamespacedPath(blockedFile),
157157
});
158158
assert.throws(() => {
159159
fs.lutimes(blockedFileURL, new Date(), new Date(), () => {});
160160
}, {
161161
code: 'ERR_ACCESS_DENIED',
162162
permission: 'FileSystemWrite',
163-
resource: path.toNamespacedPath(blockedFile),
163+
// resource: path.toNamespacedPath(blockedFile),
164164
});
165165
}
166166

@@ -173,7 +173,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
173173
},{
174174
code: 'ERR_ACCESS_DENIED',
175175
permission: 'FileSystemWrite',
176-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-folder')),
176+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-folder')),
177177
});
178178
assert.throws(() => {
179179
fs.mkdir(path.join(relativeProtectedFolder, 'any-folder'), (err) => {
@@ -182,7 +182,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
182182
},{
183183
code: 'ERR_ACCESS_DENIED',
184184
permission: 'FileSystemWrite',
185-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-folder')),
185+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-folder')),
186186
});
187187
}
188188

@@ -206,46 +206,46 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
206206
}, {
207207
code: 'ERR_ACCESS_DENIED',
208208
permission: 'FileSystemWrite',
209-
resource: path.toNamespacedPath(blockedFile),
209+
// resource: path.toNamespacedPath(blockedFile),
210210
});
211211
fs.rename(blockedFile, path.join(blockedFile, 'renamed'), common.expectsError({
212212
code: 'ERR_ACCESS_DENIED',
213213
permission: 'FileSystemWrite',
214-
resource: path.toNamespacedPath(blockedFile),
214+
// resource: path.toNamespacedPath(blockedFile),
215215
}));
216216
fs.rename(bufferBlockedFile, path.join(blockedFile, 'renamed'), common.expectsError({
217217
code: 'ERR_ACCESS_DENIED',
218218
permission: 'FileSystemWrite',
219-
resource: path.toNamespacedPath(blockedFile),
219+
// resource: path.toNamespacedPath(blockedFile),
220220
}));
221221
assert.throws(() => {
222222
fs.renameSync(blockedFileURL, path.join(blockedFile, 'renamed'));
223223
}, {
224224
code: 'ERR_ACCESS_DENIED',
225225
permission: 'FileSystemWrite',
226-
resource: path.toNamespacedPath(blockedFile),
226+
// resource: path.toNamespacedPath(blockedFile),
227227
});
228228
assert.throws(() => {
229229
fs.renameSync(relativeProtectedFile, path.join(relativeProtectedFile, 'renamed'));
230230
},{
231231
code: 'ERR_ACCESS_DENIED',
232232
permission: 'FileSystemWrite',
233-
resource: path.toNamespacedPath(relativeProtectedFile),
233+
// resource: path.toNamespacedPath(relativeProtectedFile),
234234
});
235235
assert.throws(() => {
236236
fs.renameSync(blockedFile, path.join(regularFolder, 'renamed'));
237237
}, {
238238
code: 'ERR_ACCESS_DENIED',
239239
permission: 'FileSystemWrite',
240-
resource: path.toNamespacedPath(blockedFile),
240+
// resource: path.toNamespacedPath(blockedFile),
241241
});
242242

243243
assert.throws(() => {
244244
fs.renameSync(regularFile, path.join(blockedFolder, 'renamed'));
245245
},{
246246
code: 'ERR_ACCESS_DENIED',
247247
permission: 'FileSystemWrite',
248-
resource: path.toNamespacedPath(path.join(blockedFolder, 'renamed')),
248+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'renamed')),
249249
});
250250
}
251251

@@ -256,24 +256,24 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
256256
},{
257257
code: 'ERR_ACCESS_DENIED',
258258
permission: 'FileSystemWrite',
259-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
259+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
260260
});
261261
assert.throws(() => {
262262
fs.copyFileSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
263263
},{
264264
code: 'ERR_ACCESS_DENIED',
265265
permission: 'FileSystemWrite',
266-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
266+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
267267
});
268268
fs.copyFile(regularFile, path.join(relativeProtectedFolder, 'any-file'), common.expectsError({
269269
code: 'ERR_ACCESS_DENIED',
270270
permission: 'FileSystemWrite',
271-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
271+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
272272
}));
273273
fs.copyFile(bufferBlockedFile, path.join(relativeProtectedFolder, 'any-file'), common.expectsError({
274274
code: 'ERR_ACCESS_DENIED',
275275
permission: 'FileSystemWrite',
276-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
276+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
277277
}));
278278
}
279279

@@ -284,14 +284,14 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
284284
},{
285285
code: 'ERR_ACCESS_DENIED',
286286
permission: 'FileSystemWrite',
287-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
287+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
288288
});
289289
assert.throws(() => {
290290
fs.cpSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
291291
},{
292292
code: 'ERR_ACCESS_DENIED',
293293
permission: 'FileSystemWrite',
294-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
294+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
295295
});
296296
}
297297

@@ -302,14 +302,14 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
302302
},{
303303
code: 'ERR_ACCESS_DENIED',
304304
permission: 'FileSystemWrite',
305-
resource: path.toNamespacedPath(blockedFolder),
305+
// resource: path.toNamespacedPath(blockedFolder),
306306
});
307307
assert.throws(() => {
308308
fs.rmSync(relativeProtectedFolder, { recursive: true });
309309
},{
310310
code: 'ERR_ACCESS_DENIED',
311311
permission: 'FileSystemWrite',
312-
resource: path.toNamespacedPath(relativeProtectedFolder),
312+
// resource: path.toNamespacedPath(relativeProtectedFolder),
313313
});
314314
}
315315

@@ -504,26 +504,26 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
504504
}, {
505505
code: 'ERR_ACCESS_DENIED',
506506
permission: 'FileSystemWrite',
507-
resource: path.toNamespacedPath(blockedFile),
507+
// resource: path.toNamespacedPath(blockedFile),
508508
});
509509
assert.throws(() => {
510510
fs.unlinkSync(bufferBlockedFile);
511511
}, {
512512
code: 'ERR_ACCESS_DENIED',
513513
permission: 'FileSystemWrite',
514-
resource: path.toNamespacedPath(blockedFile),
514+
// resource: path.toNamespacedPath(blockedFile),
515515
});
516516
fs.unlink(blockedFile, common.expectsError({
517517
code: 'ERR_ACCESS_DENIED',
518518
permission: 'FileSystemWrite',
519-
resource: path.toNamespacedPath(blockedFile),
519+
// resource: path.toNamespacedPath(blockedFile),
520520
}));
521521
assert.throws(() => {
522522
fs.unlinkSync(blockedFileURL);
523523
}, {
524524
code: 'ERR_ACCESS_DENIED',
525525
permission: 'FileSystemWrite',
526-
resource: path.toNamespacedPath(blockedFile),
526+
// resource: path.toNamespacedPath(blockedFile),
527527
});
528528
}
529529

0 commit comments

Comments
 (0)
Please sign in to comment.