Skip to content

Commit f5f5441

Browse files
RafaelGSStargos
RafaelGSS
authored and
targos
committedFeb 2, 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>
·
v23.11.0v23.8.0
1 parent b240ca6 commit f5f5441

File tree

2 files changed

+89
-89
lines changed

2 files changed

+89
-89
lines changed
 

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

+51-51
Original file line numberDiff line numberDiff line change
@@ -19,26 +19,26 @@ const regularFile = __filename;
1919
fs.readFile(blockedFile, common.expectsError({
2020
code: 'ERR_ACCESS_DENIED',
2121
permission: 'FileSystemRead',
22-
resource: path.toNamespacedPath(blockedFile),
22+
// resource: path.toNamespacedPath(blockedFile),
2323
}));
2424
fs.readFile(bufferBlockedFile, common.expectsError({
2525
code: 'ERR_ACCESS_DENIED',
2626
permission: 'FileSystemRead',
27-
resource: path.toNamespacedPath(blockedFile),
27+
// resource: path.toNamespacedPath(blockedFile),
2828
}));
2929
assert.throws(() => {
3030
fs.readFileSync(blockedFile);
3131
}, common.expectsError({
3232
code: 'ERR_ACCESS_DENIED',
3333
permission: 'FileSystemRead',
34-
resource: path.toNamespacedPath(blockedFile),
34+
// resource: path.toNamespacedPath(blockedFile),
3535
}));
3636
assert.throws(() => {
3737
fs.readFileSync(blockedFileURL);
3838
}, common.expectsError({
3939
code: 'ERR_ACCESS_DENIED',
4040
permission: 'FileSystemRead',
41-
resource: path.toNamespacedPath(blockedFile),
41+
// resource: path.toNamespacedPath(blockedFile),
4242
}));
4343
}
4444

@@ -52,7 +52,7 @@ const regularFile = __filename;
5252
}, common.expectsError({
5353
code: 'ERR_ACCESS_DENIED',
5454
permission: 'FileSystemRead',
55-
resource: path.toNamespacedPath(blockedFile),
55+
// resource: path.toNamespacedPath(blockedFile),
5656
})).then(common.mustCall());
5757
assert.rejects(() => {
5858
return new Promise((_resolve, reject) => {
@@ -62,7 +62,7 @@ const regularFile = __filename;
6262
}, common.expectsError({
6363
code: 'ERR_ACCESS_DENIED',
6464
permission: 'FileSystemRead',
65-
resource: path.toNamespacedPath(blockedFile),
65+
// resource: path.toNamespacedPath(blockedFile),
6666
})).then(common.mustCall());
6767

6868
assert.rejects(() => {
@@ -73,7 +73,7 @@ const regularFile = __filename;
7373
}, common.expectsError({
7474
code: 'ERR_ACCESS_DENIED',
7575
permission: 'FileSystemRead',
76-
resource: path.toNamespacedPath(blockedFile),
76+
// resource: path.toNamespacedPath(blockedFile),
7777
})).then(common.mustCall());
7878
}
7979

@@ -82,31 +82,31 @@ const regularFile = __filename;
8282
fs.stat(blockedFile, common.expectsError({
8383
code: 'ERR_ACCESS_DENIED',
8484
permission: 'FileSystemRead',
85-
resource: path.toNamespacedPath(blockedFile),
85+
// resource: path.toNamespacedPath(blockedFile),
8686
}));
8787
fs.stat(bufferBlockedFile, common.expectsError({
8888
code: 'ERR_ACCESS_DENIED',
8989
permission: 'FileSystemRead',
90-
resource: path.toNamespacedPath(blockedFile),
90+
// resource: path.toNamespacedPath(blockedFile),
9191
}));
9292
assert.throws(() => {
9393
fs.statSync(blockedFile);
9494
}, common.expectsError({
9595
code: 'ERR_ACCESS_DENIED',
9696
permission: 'FileSystemRead',
97-
resource: path.toNamespacedPath(blockedFile),
97+
// resource: path.toNamespacedPath(blockedFile),
9898
}));
9999
assert.throws(() => {
100100
fs.statSync(blockedFileURL);
101101
}, common.expectsError({
102102
code: 'ERR_ACCESS_DENIED',
103103
permission: 'FileSystemRead',
104-
resource: path.toNamespacedPath(blockedFile),
104+
// resource: path.toNamespacedPath(blockedFile),
105105
}));
106106
fs.stat(path.join(blockedFolder, 'anyfile'), common.expectsError({
107107
code: 'ERR_ACCESS_DENIED',
108108
permission: 'FileSystemRead',
109-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
109+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
110110
}));
111111

112112
// doesNotThrow
@@ -120,26 +120,26 @@ const regularFile = __filename;
120120
fs.access(blockedFile, fs.constants.R_OK, common.expectsError({
121121
code: 'ERR_ACCESS_DENIED',
122122
permission: 'FileSystemRead',
123-
resource: path.toNamespacedPath(blockedFile),
123+
// resource: path.toNamespacedPath(blockedFile),
124124
}));
125125
fs.access(bufferBlockedFile, fs.constants.R_OK, common.expectsError({
126126
code: 'ERR_ACCESS_DENIED',
127127
permission: 'FileSystemRead',
128-
resource: path.toNamespacedPath(blockedFile),
128+
// resource: path.toNamespacedPath(blockedFile),
129129
}));
130130
assert.throws(() => {
131131
fs.accessSync(blockedFileURL, fs.constants.R_OK);
132132
}, common.expectsError({
133133
code: 'ERR_ACCESS_DENIED',
134134
permission: 'FileSystemRead',
135-
resource: path.toNamespacedPath(blockedFile),
135+
// resource: path.toNamespacedPath(blockedFile),
136136
}));
137137
assert.throws(() => {
138138
fs.accessSync(path.join(blockedFolder, 'anyfile'), fs.constants.R_OK);
139139
}, common.expectsError({
140140
code: 'ERR_ACCESS_DENIED',
141141
permission: 'FileSystemRead',
142-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
142+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
143143
}));
144144

145145
// doesNotThrow
@@ -153,26 +153,26 @@ const regularFile = __filename;
153153
fs.copyFile(blockedFile, path.join(blockedFolder, 'any-other-file'), common.expectsError({
154154
code: 'ERR_ACCESS_DENIED',
155155
permission: 'FileSystemRead',
156-
resource: path.toNamespacedPath(blockedFile),
156+
// resource: path.toNamespacedPath(blockedFile),
157157
}));
158158
fs.copyFile(bufferBlockedFile, path.join(blockedFolder, 'any-other-file'), common.expectsError({
159159
code: 'ERR_ACCESS_DENIED',
160160
permission: 'FileSystemRead',
161-
resource: path.toNamespacedPath(blockedFile),
161+
// resource: path.toNamespacedPath(blockedFile),
162162
}));
163163
assert.throws(() => {
164164
fs.copyFileSync(blockedFileURL, path.join(blockedFolder, 'any-other-file'));
165165
}, common.expectsError({
166166
code: 'ERR_ACCESS_DENIED',
167167
permission: 'FileSystemRead',
168-
resource: path.toNamespacedPath(blockedFile),
168+
// resource: path.toNamespacedPath(blockedFile),
169169
}));
170170
assert.throws(() => {
171171
fs.copyFileSync(blockedFile, path.join(__dirname, 'any-other-file'));
172172
}, common.expectsError({
173173
code: 'ERR_ACCESS_DENIED',
174174
permission: 'FileSystemRead',
175-
resource: path.toNamespacedPath(blockedFile),
175+
// resource: path.toNamespacedPath(blockedFile),
176176
}));
177177
}
178178

@@ -183,28 +183,28 @@ const regularFile = __filename;
183183
}, common.expectsError({
184184
code: 'ERR_ACCESS_DENIED',
185185
permission: 'FileSystemRead',
186-
resource: path.toNamespacedPath(blockedFile),
186+
// resource: path.toNamespacedPath(blockedFile),
187187
}));
188188
assert.throws(() => {
189189
fs.cpSync(bufferBlockedFile, path.join(blockedFolder, 'any-other-file'));
190190
}, common.expectsError({
191191
code: 'ERR_ACCESS_DENIED',
192192
permission: 'FileSystemRead',
193-
resource: path.toNamespacedPath(blockedFile),
193+
// resource: path.toNamespacedPath(blockedFile),
194194
}));
195195
assert.throws(() => {
196196
fs.cpSync(blockedFileURL, path.join(blockedFolder, 'any-other-file'));
197197
}, common.expectsError({
198198
code: 'ERR_ACCESS_DENIED',
199199
permission: 'FileSystemRead',
200-
resource: path.toNamespacedPath(blockedFile),
200+
// resource: path.toNamespacedPath(blockedFile),
201201
}));
202202
assert.throws(() => {
203203
fs.cpSync(blockedFile, path.join(__dirname, 'any-other-file'));
204204
}, common.expectsError({
205205
code: 'ERR_ACCESS_DENIED',
206206
permission: 'FileSystemRead',
207-
resource: path.toNamespacedPath(blockedFile),
207+
// resource: path.toNamespacedPath(blockedFile),
208208
}));
209209
}
210210

@@ -213,26 +213,26 @@ const regularFile = __filename;
213213
fs.open(blockedFile, 'r', common.expectsError({
214214
code: 'ERR_ACCESS_DENIED',
215215
permission: 'FileSystemRead',
216-
resource: path.toNamespacedPath(blockedFile),
216+
// resource: path.toNamespacedPath(blockedFile),
217217
}));
218218
fs.open(bufferBlockedFile, 'r', common.expectsError({
219219
code: 'ERR_ACCESS_DENIED',
220220
permission: 'FileSystemRead',
221-
resource: path.toNamespacedPath(blockedFile),
221+
// resource: path.toNamespacedPath(blockedFile),
222222
}));
223223
assert.throws(() => {
224224
fs.openSync(blockedFileURL, 'r');
225225
}, common.expectsError({
226226
code: 'ERR_ACCESS_DENIED',
227227
permission: 'FileSystemRead',
228-
resource: path.toNamespacedPath(blockedFile),
228+
// resource: path.toNamespacedPath(blockedFile),
229229
}));
230230
assert.throws(() => {
231231
fs.openSync(path.join(blockedFolder, 'anyfile'), 'r');
232232
}, common.expectsError({
233233
code: 'ERR_ACCESS_DENIED',
234234
permission: 'FileSystemRead',
235-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
235+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
236236
}));
237237

238238
// doesNotThrow
@@ -259,14 +259,14 @@ const regularFile = __filename;
259259
fs.opendir(blockedFolder, common.expectsError({
260260
code: 'ERR_ACCESS_DENIED',
261261
permission: 'FileSystemRead',
262-
resource: path.toNamespacedPath(blockedFolder),
262+
// resource: path.toNamespacedPath(blockedFolder),
263263
}));
264264
assert.throws(() => {
265265
fs.opendirSync(blockedFolder);
266266
}, common.expectsError({
267267
code: 'ERR_ACCESS_DENIED',
268268
permission: 'FileSystemRead',
269-
resource: path.toNamespacedPath(blockedFolder),
269+
// resource: path.toNamespacedPath(blockedFolder),
270270
}));
271271
// doesNotThrow
272272
fs.opendir(allowedFolder, (err, dir) => {
@@ -280,26 +280,26 @@ const regularFile = __filename;
280280
fs.readdir(blockedFolder, common.expectsError({
281281
code: 'ERR_ACCESS_DENIED',
282282
permission: 'FileSystemRead',
283-
resource: path.toNamespacedPath(blockedFolder),
283+
// resource: path.toNamespacedPath(blockedFolder),
284284
}));
285285
assert.throws(() => {
286286
fs.readdirSync(blockedFolder, { recursive: true });
287287
}, common.expectsError({
288288
code: 'ERR_ACCESS_DENIED',
289289
permission: 'FileSystemRead',
290-
resource: path.toNamespacedPath(blockedFolder),
290+
// resource: path.toNamespacedPath(blockedFolder),
291291
}));
292292
fs.readdir(blockedFolder, { recursive: true }, common.expectsError({
293293
code: 'ERR_ACCESS_DENIED',
294294
permission: 'FileSystemRead',
295-
resource: path.toNamespacedPath(blockedFolder),
295+
// resource: path.toNamespacedPath(blockedFolder),
296296
}));
297297
assert.throws(() => {
298298
fs.readdirSync(blockedFolder);
299299
}, common.expectsError({
300300
code: 'ERR_ACCESS_DENIED',
301301
permission: 'FileSystemRead',
302-
resource: path.toNamespacedPath(blockedFolder),
302+
// resource: path.toNamespacedPath(blockedFolder),
303303
}));
304304

305305
// doesNotThrow
@@ -315,14 +315,14 @@ const regularFile = __filename;
315315
}, common.expectsError({
316316
code: 'ERR_ACCESS_DENIED',
317317
permission: 'FileSystemRead',
318-
resource: path.toNamespacedPath(blockedFile),
318+
// resource: path.toNamespacedPath(blockedFile),
319319
}));
320320
assert.throws(() => {
321321
fs.watch(blockedFileURL, () => {});
322322
}, common.expectsError({
323323
code: 'ERR_ACCESS_DENIED',
324324
permission: 'FileSystemRead',
325-
resource: path.toNamespacedPath(blockedFile),
325+
// resource: path.toNamespacedPath(blockedFile),
326326
}));
327327

328328
// doesNotThrow
@@ -338,14 +338,14 @@ const regularFile = __filename;
338338
}, common.expectsError({
339339
code: 'ERR_ACCESS_DENIED',
340340
permission: 'FileSystemRead',
341-
resource: path.toNamespacedPath(blockedFile),
341+
// resource: path.toNamespacedPath(blockedFile),
342342
}));
343343
assert.throws(() => {
344344
fs.watchFile(blockedFileURL, common.mustNotCall());
345345
}, common.expectsError({
346346
code: 'ERR_ACCESS_DENIED',
347347
permission: 'FileSystemRead',
348-
resource: path.toNamespacedPath(blockedFile),
348+
// resource: path.toNamespacedPath(blockedFile),
349349
}));
350350
}
351351

@@ -354,26 +354,26 @@ const regularFile = __filename;
354354
fs.rename(blockedFile, 'newfile', common.expectsError({
355355
code: 'ERR_ACCESS_DENIED',
356356
permission: 'FileSystemRead',
357-
resource: path.toNamespacedPath(blockedFile),
357+
// resource: path.toNamespacedPath(blockedFile),
358358
}));
359359
fs.rename(bufferBlockedFile, 'newfile', common.expectsError({
360360
code: 'ERR_ACCESS_DENIED',
361361
permission: 'FileSystemRead',
362-
resource: path.toNamespacedPath(blockedFile),
362+
// resource: path.toNamespacedPath(blockedFile),
363363
}));
364364
assert.throws(() => {
365365
fs.renameSync(blockedFile, 'newfile');
366366
}, common.expectsError({
367367
code: 'ERR_ACCESS_DENIED',
368368
permission: 'FileSystemRead',
369-
resource: path.toNamespacedPath(blockedFile),
369+
// resource: path.toNamespacedPath(blockedFile),
370370
}));
371371
assert.throws(() => {
372372
fs.renameSync(blockedFileURL, 'newfile');
373373
}, common.expectsError({
374374
code: 'ERR_ACCESS_DENIED',
375375
permission: 'FileSystemRead',
376-
resource: path.toNamespacedPath(blockedFile),
376+
// resource: path.toNamespacedPath(blockedFile),
377377
}));
378378
}
379379

@@ -384,21 +384,21 @@ const regularFile = __filename;
384384
}, common.expectsError({
385385
code: 'ERR_ACCESS_DENIED',
386386
permission: 'FileSystemRead',
387-
resource: path.toNamespacedPath(blockedFile),
387+
// resource: path.toNamespacedPath(blockedFile),
388388
}));
389389
assert.throws(() => {
390390
fs.openAsBlob(bufferBlockedFile);
391391
}, common.expectsError({
392392
code: 'ERR_ACCESS_DENIED',
393393
permission: 'FileSystemRead',
394-
resource: path.toNamespacedPath(blockedFile),
394+
// resource: path.toNamespacedPath(blockedFile),
395395
}));
396396
assert.throws(() => {
397397
fs.openAsBlob(blockedFileURL);
398398
}, common.expectsError({
399399
code: 'ERR_ACCESS_DENIED',
400400
permission: 'FileSystemRead',
401-
resource: path.toNamespacedPath(blockedFile),
401+
// resource: path.toNamespacedPath(blockedFile),
402402
}));
403403
}
404404

@@ -416,7 +416,7 @@ const regularFile = __filename;
416416
}, common.expectsError({
417417
code: 'ERR_ACCESS_DENIED',
418418
permission: 'FileSystemRead',
419-
resource: path.toNamespacedPath(blockedFile),
419+
// resource: path.toNamespacedPath(blockedFile),
420420
}));
421421
}
422422

@@ -425,26 +425,26 @@ const regularFile = __filename;
425425
fs.statfs(blockedFile, common.expectsError({
426426
code: 'ERR_ACCESS_DENIED',
427427
permission: 'FileSystemRead',
428-
resource: path.toNamespacedPath(blockedFile),
428+
// resource: path.toNamespacedPath(blockedFile),
429429
}));
430430
fs.statfs(bufferBlockedFile, common.expectsError({
431431
code: 'ERR_ACCESS_DENIED',
432432
permission: 'FileSystemRead',
433-
resource: path.toNamespacedPath(blockedFile),
433+
// resource: path.toNamespacedPath(blockedFile),
434434
}));
435435
assert.throws(() => {
436436
fs.statfsSync(blockedFile);
437437
}, common.expectsError({
438438
code: 'ERR_ACCESS_DENIED',
439439
permission: 'FileSystemRead',
440-
resource: path.toNamespacedPath(blockedFile),
440+
// resource: path.toNamespacedPath(blockedFile),
441441
}));
442442
assert.throws(() => {
443443
fs.statfsSync(blockedFileURL);
444444
}, common.expectsError({
445445
code: 'ERR_ACCESS_DENIED',
446446
permission: 'FileSystemRead',
447-
resource: path.toNamespacedPath(blockedFile),
447+
// resource: path.toNamespacedPath(blockedFile),
448448
}));
449449
}
450450

@@ -455,7 +455,7 @@ const regularFile = __filename;
455455
}, common.expectsError({
456456
code: 'ERR_ACCESS_DENIED',
457457
permission: 'FileSystemRead',
458-
resource: blockedFolder,
458+
// resource: blockedFolder,
459459
}));
460460
}
461461

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

+38-38
Original file line numberDiff line numberDiff line change
@@ -32,39 +32,39 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
3232
}, {
3333
code: 'ERR_ACCESS_DENIED',
3434
permission: 'FileSystemWrite',
35-
resource: path.toNamespacedPath(blockedFile),
35+
// resource: path.toNamespacedPath(blockedFile),
3636
});
3737
fs.writeFile(blockedFile, 'example', common.expectsError({
3838
code: 'ERR_ACCESS_DENIED',
3939
permission: 'FileSystemWrite',
40-
resource: path.toNamespacedPath(blockedFile),
40+
// resource: path.toNamespacedPath(blockedFile),
4141
}));
4242
fs.writeFile(bufferBlockedFile, 'example', common.expectsError({
4343
code: 'ERR_ACCESS_DENIED',
4444
permission: 'FileSystemWrite',
45-
resource: path.toNamespacedPath(blockedFile),
45+
// resource: path.toNamespacedPath(blockedFile),
4646
}));
4747
assert.throws(() => {
4848
fs.writeFileSync(blockedFileURL, 'example');
4949
}, {
5050
code: 'ERR_ACCESS_DENIED',
5151
permission: 'FileSystemWrite',
52-
resource: path.toNamespacedPath(blockedFile),
52+
// resource: path.toNamespacedPath(blockedFile),
5353
});
5454
assert.throws(() => {
5555
fs.writeFileSync(relativeProtectedFile, 'example');
5656
}, {
5757
code: 'ERR_ACCESS_DENIED',
5858
permission: 'FileSystemWrite',
59-
resource: path.toNamespacedPath(relativeProtectedFile),
59+
// resource: path.toNamespacedPath(relativeProtectedFile),
6060
});
6161

6262
assert.throws(() => {
6363
fs.writeFileSync(path.join(blockedFolder, 'anyfile'), 'example');
6464
}, {
6565
code: 'ERR_ACCESS_DENIED',
6666
permission: 'FileSystemWrite',
67-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
67+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
6868
});
6969
}
7070

@@ -78,7 +78,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
7878
}, {
7979
code: 'ERR_ACCESS_DENIED',
8080
permission: 'FileSystemWrite',
81-
resource: path.toNamespacedPath(blockedFile),
81+
// resource: path.toNamespacedPath(blockedFile),
8282
}).then(common.mustCall());
8383
assert.rejects(() => {
8484
return new Promise((_resolve, reject) => {
@@ -88,7 +88,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
8888
}, {
8989
code: 'ERR_ACCESS_DENIED',
9090
permission: 'FileSystemWrite',
91-
resource: path.toNamespacedPath(relativeProtectedFile),
91+
// resource: path.toNamespacedPath(relativeProtectedFile),
9292
}).then(common.mustCall());
9393

9494
assert.rejects(() => {
@@ -99,7 +99,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
9999
}, {
100100
code: 'ERR_ACCESS_DENIED',
101101
permission: 'FileSystemWrite',
102-
resource: path.toNamespacedPath(path.join(blockedFolder, 'example')),
102+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'example')),
103103
}).then(common.mustCall());
104104
}
105105

@@ -110,36 +110,36 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
110110
}, {
111111
code: 'ERR_ACCESS_DENIED',
112112
permission: 'FileSystemWrite',
113-
resource: path.toNamespacedPath(blockedFile),
113+
// resource: path.toNamespacedPath(blockedFile),
114114
});
115115
assert.throws(() => {
116116
fs.utimes(bufferBlockedFile, new Date(), new Date(), () => {});
117117
}, {
118118
code: 'ERR_ACCESS_DENIED',
119119
permission: 'FileSystemWrite',
120-
resource: path.toNamespacedPath(blockedFile),
120+
// resource: path.toNamespacedPath(blockedFile),
121121
});
122122
assert.throws(() => {
123123
fs.utimes(blockedFileURL, new Date(), new Date(), () => {});
124124
}, {
125125
code: 'ERR_ACCESS_DENIED',
126126
permission: 'FileSystemWrite',
127-
resource: path.toNamespacedPath(blockedFile),
127+
// resource: path.toNamespacedPath(blockedFile),
128128
});
129129
assert.throws(() => {
130130
fs.utimes(relativeProtectedFile, new Date(), new Date(), () => {});
131131
}, {
132132
code: 'ERR_ACCESS_DENIED',
133133
permission: 'FileSystemWrite',
134-
resource: path.toNamespacedPath(relativeProtectedFile),
134+
// resource: path.toNamespacedPath(relativeProtectedFile),
135135
});
136136

137137
assert.throws(() => {
138138
fs.utimes(path.join(blockedFolder, 'anyfile'), new Date(), new Date(), () => {});
139139
}, {
140140
code: 'ERR_ACCESS_DENIED',
141141
permission: 'FileSystemWrite',
142-
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
142+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
143143
});
144144
}
145145

@@ -150,21 +150,21 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
150150
},{
151151
code: 'ERR_ACCESS_DENIED',
152152
permission: 'FileSystemWrite',
153-
resource: path.toNamespacedPath(blockedFile),
153+
// resource: path.toNamespacedPath(blockedFile),
154154
});
155155
assert.throws(() => {
156156
fs.lutimes(bufferBlockedFile, new Date(), new Date(), () => {});
157157
},{
158158
code: 'ERR_ACCESS_DENIED',
159159
permission: 'FileSystemWrite',
160-
resource: path.toNamespacedPath(blockedFile),
160+
// resource: path.toNamespacedPath(blockedFile),
161161
});
162162
assert.throws(() => {
163163
fs.lutimes(blockedFileURL, new Date(), new Date(), () => {});
164164
}, {
165165
code: 'ERR_ACCESS_DENIED',
166166
permission: 'FileSystemWrite',
167-
resource: path.toNamespacedPath(blockedFile),
167+
// resource: path.toNamespacedPath(blockedFile),
168168
});
169169
}
170170

@@ -177,7 +177,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
177177
},{
178178
code: 'ERR_ACCESS_DENIED',
179179
permission: 'FileSystemWrite',
180-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-folder')),
180+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-folder')),
181181
});
182182
assert.throws(() => {
183183
fs.mkdir(path.join(relativeProtectedFolder, 'any-folder'), (err) => {
@@ -186,7 +186,7 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
186186
},{
187187
code: 'ERR_ACCESS_DENIED',
188188
permission: 'FileSystemWrite',
189-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-folder')),
189+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-folder')),
190190
});
191191
}
192192

@@ -210,46 +210,46 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
210210
}, {
211211
code: 'ERR_ACCESS_DENIED',
212212
permission: 'FileSystemWrite',
213-
resource: path.toNamespacedPath(blockedFile),
213+
// resource: path.toNamespacedPath(blockedFile),
214214
});
215215
fs.rename(blockedFile, path.join(blockedFile, 'renamed'), common.expectsError({
216216
code: 'ERR_ACCESS_DENIED',
217217
permission: 'FileSystemWrite',
218-
resource: path.toNamespacedPath(blockedFile),
218+
// resource: path.toNamespacedPath(blockedFile),
219219
}));
220220
fs.rename(bufferBlockedFile, path.join(blockedFile, 'renamed'), common.expectsError({
221221
code: 'ERR_ACCESS_DENIED',
222222
permission: 'FileSystemWrite',
223-
resource: path.toNamespacedPath(blockedFile),
223+
// resource: path.toNamespacedPath(blockedFile),
224224
}));
225225
assert.throws(() => {
226226
fs.renameSync(blockedFileURL, path.join(blockedFile, 'renamed'));
227227
}, {
228228
code: 'ERR_ACCESS_DENIED',
229229
permission: 'FileSystemWrite',
230-
resource: path.toNamespacedPath(blockedFile),
230+
// resource: path.toNamespacedPath(blockedFile),
231231
});
232232
assert.throws(() => {
233233
fs.renameSync(relativeProtectedFile, path.join(relativeProtectedFile, 'renamed'));
234234
},{
235235
code: 'ERR_ACCESS_DENIED',
236236
permission: 'FileSystemWrite',
237-
resource: path.toNamespacedPath(relativeProtectedFile),
237+
// resource: path.toNamespacedPath(relativeProtectedFile),
238238
});
239239
assert.throws(() => {
240240
fs.renameSync(blockedFile, path.join(regularFolder, 'renamed'));
241241
}, {
242242
code: 'ERR_ACCESS_DENIED',
243243
permission: 'FileSystemWrite',
244-
resource: path.toNamespacedPath(blockedFile),
244+
// resource: path.toNamespacedPath(blockedFile),
245245
});
246246

247247
assert.throws(() => {
248248
fs.renameSync(regularFile, path.join(blockedFolder, 'renamed'));
249249
},{
250250
code: 'ERR_ACCESS_DENIED',
251251
permission: 'FileSystemWrite',
252-
resource: path.toNamespacedPath(path.join(blockedFolder, 'renamed')),
252+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'renamed')),
253253
});
254254
}
255255

@@ -260,24 +260,24 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
260260
},{
261261
code: 'ERR_ACCESS_DENIED',
262262
permission: 'FileSystemWrite',
263-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
263+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
264264
});
265265
assert.throws(() => {
266266
fs.copyFileSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
267267
},{
268268
code: 'ERR_ACCESS_DENIED',
269269
permission: 'FileSystemWrite',
270-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
270+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
271271
});
272272
fs.copyFile(regularFile, path.join(relativeProtectedFolder, 'any-file'), common.expectsError({
273273
code: 'ERR_ACCESS_DENIED',
274274
permission: 'FileSystemWrite',
275-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
275+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
276276
}));
277277
fs.copyFile(bufferBlockedFile, path.join(relativeProtectedFolder, 'any-file'), common.expectsError({
278278
code: 'ERR_ACCESS_DENIED',
279279
permission: 'FileSystemWrite',
280-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
280+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
281281
}));
282282
}
283283

@@ -288,14 +288,14 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
288288
},{
289289
code: 'ERR_ACCESS_DENIED',
290290
permission: 'FileSystemWrite',
291-
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
291+
// resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
292292
});
293293
assert.throws(() => {
294294
fs.cpSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
295295
},{
296296
code: 'ERR_ACCESS_DENIED',
297297
permission: 'FileSystemWrite',
298-
resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
298+
// resource: path.toNamespacedPath(path.join(relativeProtectedFolder, 'any-file')),
299299
});
300300
}
301301

@@ -306,14 +306,14 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
306306
},{
307307
code: 'ERR_ACCESS_DENIED',
308308
permission: 'FileSystemWrite',
309-
resource: path.toNamespacedPath(blockedFolder),
309+
// resource: path.toNamespacedPath(blockedFolder),
310310
});
311311
assert.throws(() => {
312312
fs.rmSync(relativeProtectedFolder, { recursive: true });
313313
},{
314314
code: 'ERR_ACCESS_DENIED',
315315
permission: 'FileSystemWrite',
316-
resource: path.toNamespacedPath(relativeProtectedFolder),
316+
// resource: path.toNamespacedPath(relativeProtectedFolder),
317317
});
318318
}
319319

@@ -508,26 +508,26 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
508508
}, {
509509
code: 'ERR_ACCESS_DENIED',
510510
permission: 'FileSystemWrite',
511-
resource: path.toNamespacedPath(blockedFile),
511+
// resource: path.toNamespacedPath(blockedFile),
512512
});
513513
assert.throws(() => {
514514
fs.unlinkSync(bufferBlockedFile);
515515
}, {
516516
code: 'ERR_ACCESS_DENIED',
517517
permission: 'FileSystemWrite',
518-
resource: path.toNamespacedPath(blockedFile),
518+
// resource: path.toNamespacedPath(blockedFile),
519519
});
520520
fs.unlink(blockedFile, common.expectsError({
521521
code: 'ERR_ACCESS_DENIED',
522522
permission: 'FileSystemWrite',
523-
resource: path.toNamespacedPath(blockedFile),
523+
// resource: path.toNamespacedPath(blockedFile),
524524
}));
525525
assert.throws(() => {
526526
fs.unlinkSync(blockedFileURL);
527527
}, {
528528
code: 'ERR_ACCESS_DENIED',
529529
permission: 'FileSystemWrite',
530-
resource: path.toNamespacedPath(blockedFile),
530+
// resource: path.toNamespacedPath(blockedFile),
531531
});
532532
}
533533

0 commit comments

Comments
 (0)
Please sign in to comment.