Skip to content

Commit 09a506f

Browse files
AndresMorelosAndresMorelos
authored
test: remove unneeded common.expectsError for asserts
PR-URL: #51353 Reviewed-By: Luigi Pinca <[email protected]> Reviewed-By: Rafael Gonzaga <[email protected]> Reviewed-By: Trivikram Kamat <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]>
1 parent bf37d4b commit 09a506f

File tree

1 file changed

+48
-48
lines changed

1 file changed

+48
-48
lines changed

‎test/fixtures/permission/fs-write.js‎

Lines changed: 48 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -25,26 +25,26 @@ const absoluteProtectedFolder = path.resolve(relativeProtectedFolder);
2525
{
2626
assert.throws(() => {
2727
fs.writeFile(blockedFile, 'example', () => {});
28-
}, common.expectsError({
28+
}, {
2929
code: 'ERR_ACCESS_DENIED',
3030
permission: 'FileSystemWrite',
3131
resource: path.toNamespacedPath(blockedFile),
32-
}));
32+
});
3333
assert.throws(() => {
3434
fs.writeFile(relativeProtectedFile, 'example', () => {});
35-
}, common.expectsError({
35+
}, {
3636
code: 'ERR_ACCESS_DENIED',
3737
permission: 'FileSystemWrite',
3838
resource: path.toNamespacedPath(absoluteProtectedFile),
39-
}));
39+
});
4040

4141
assert.throws(() => {
4242
fs.writeFile(path.join(blockedFolder, 'anyfile'), 'example', () => {});
43-
}, common.expectsError({
43+
}, {
4444
code: 'ERR_ACCESS_DENIED',
4545
permission: 'FileSystemWrite',
4646
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
47-
}));
47+
});
4848
}
4949

5050
// fs.createWriteStream
@@ -54,69 +54,69 @@ const absoluteProtectedFolder = path.resolve(relativeProtectedFolder);
5454
const stream = fs.createWriteStream(blockedFile);
5555
stream.on('error', reject);
5656
});
57-
}, common.expectsError({
57+
}, {
5858
code: 'ERR_ACCESS_DENIED',
5959
permission: 'FileSystemWrite',
6060
resource: path.toNamespacedPath(blockedFile),
61-
})).then(common.mustCall());
61+
}).then(common.mustCall());
6262
assert.rejects(() => {
6363
return new Promise((_resolve, reject) => {
6464
const stream = fs.createWriteStream(relativeProtectedFile);
6565
stream.on('error', reject);
6666
});
67-
}, common.expectsError({
67+
}, {
6868
code: 'ERR_ACCESS_DENIED',
6969
permission: 'FileSystemWrite',
7070
resource: path.toNamespacedPath(absoluteProtectedFile),
71-
})).then(common.mustCall());
71+
}).then(common.mustCall());
7272

7373
assert.rejects(() => {
7474
return new Promise((_resolve, reject) => {
7575
const stream = fs.createWriteStream(path.join(blockedFolder, 'example'));
7676
stream.on('error', reject);
7777
});
78-
}, common.expectsError({
78+
}, {
7979
code: 'ERR_ACCESS_DENIED',
8080
permission: 'FileSystemWrite',
8181
resource: path.toNamespacedPath(path.join(blockedFolder, 'example')),
82-
})).then(common.mustCall());
82+
}).then(common.mustCall());
8383
}
8484

8585
// fs.utimes
8686
{
8787
assert.throws(() => {
8888
fs.utimes(blockedFile, new Date(), new Date(), () => {});
89-
}, common.expectsError({
89+
}, {
9090
code: 'ERR_ACCESS_DENIED',
9191
permission: 'FileSystemWrite',
9292
resource: path.toNamespacedPath(blockedFile),
93-
}));
93+
});
9494
assert.throws(() => {
9595
fs.utimes(relativeProtectedFile, new Date(), new Date(), () => {});
96-
}, common.expectsError({
96+
}, {
9797
code: 'ERR_ACCESS_DENIED',
9898
permission: 'FileSystemWrite',
9999
resource: path.toNamespacedPath(absoluteProtectedFile),
100-
}));
100+
});
101101

102102
assert.throws(() => {
103103
fs.utimes(path.join(blockedFolder, 'anyfile'), new Date(), new Date(), () => {});
104-
}, common.expectsError({
104+
}, {
105105
code: 'ERR_ACCESS_DENIED',
106106
permission: 'FileSystemWrite',
107107
resource: path.toNamespacedPath(path.join(blockedFolder, 'anyfile')),
108-
}));
108+
});
109109
}
110110

111111
// fs.lutimes
112112
{
113113
assert.throws(() => {
114114
fs.lutimes(blockedFile, new Date(), new Date(), () => {});
115-
}, common.expectsError({
115+
},{
116116
code: 'ERR_ACCESS_DENIED',
117117
permission: 'FileSystemWrite',
118118
resource: path.toNamespacedPath(blockedFile),
119-
}));
119+
});
120120
}
121121

122122
// fs.mkdir
@@ -125,37 +125,37 @@ const absoluteProtectedFolder = path.resolve(relativeProtectedFolder);
125125
fs.mkdir(path.join(blockedFolder, 'any-folder'), (err) => {
126126
assert.ifError(err);
127127
});
128-
}, common.expectsError({
128+
},{
129129
code: 'ERR_ACCESS_DENIED',
130130
permission: 'FileSystemWrite',
131131
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-folder')),
132-
}));
132+
});
133133
assert.throws(() => {
134134
fs.mkdir(path.join(relativeProtectedFolder, 'any-folder'), (err) => {
135135
assert.ifError(err);
136136
});
137-
}, common.expectsError({
137+
},{
138138
code: 'ERR_ACCESS_DENIED',
139139
permission: 'FileSystemWrite',
140140
resource: path.toNamespacedPath(path.join(absoluteProtectedFolder, 'any-folder')),
141-
}));
141+
});
142142
}
143143

144144
{
145145
assert.throws(() => {
146146
fs.mkdtempSync(path.join(blockedFolder, 'any-folder'));
147-
}, common.expectsError({
147+
},{
148148
code: 'ERR_ACCESS_DENIED',
149149
permission: 'FileSystemWrite',
150-
}));
150+
});
151151
assert.throws(() => {
152152
fs.mkdtemp(path.join(relativeProtectedFolder, 'any-folder'), (err) => {
153153
assert.ifError(err);
154154
});
155-
}, common.expectsError({
155+
},{
156156
code: 'ERR_ACCESS_DENIED',
157157
permission: 'FileSystemWrite',
158-
}));
158+
});
159159
}
160160

161161
// fs.rename
@@ -164,93 +164,93 @@ const absoluteProtectedFolder = path.resolve(relativeProtectedFolder);
164164
fs.rename(blockedFile, path.join(blockedFile, 'renamed'), (err) => {
165165
assert.ifError(err);
166166
});
167-
}, common.expectsError({
167+
},{
168168
code: 'ERR_ACCESS_DENIED',
169169
permission: 'FileSystemWrite',
170170
resource: path.toNamespacedPath(blockedFile),
171-
}));
171+
});
172172
assert.throws(() => {
173173
fs.rename(relativeProtectedFile, path.join(relativeProtectedFile, 'renamed'), (err) => {
174174
assert.ifError(err);
175175
});
176-
}, common.expectsError({
176+
},{
177177
code: 'ERR_ACCESS_DENIED',
178178
permission: 'FileSystemWrite',
179179
resource: path.toNamespacedPath(absoluteProtectedFile),
180-
}));
180+
});
181181
assert.throws(() => {
182182
fs.rename(blockedFile, path.join(regularFolder, 'renamed'), (err) => {
183183
assert.ifError(err);
184184
});
185-
}, common.expectsError({
185+
},{
186186
code: 'ERR_ACCESS_DENIED',
187187
permission: 'FileSystemWrite',
188188
resource: path.toNamespacedPath(blockedFile),
189-
}));
189+
});
190190

191191
assert.throws(() => {
192192
fs.rename(regularFile, path.join(blockedFolder, 'renamed'), (err) => {
193193
assert.ifError(err);
194194
});
195-
}, common.expectsError({
195+
},{
196196
code: 'ERR_ACCESS_DENIED',
197197
permission: 'FileSystemWrite',
198198
resource: path.toNamespacedPath(path.join(blockedFolder, 'renamed')),
199-
}));
199+
});
200200
}
201201

202202
// fs.copyFile
203203
{
204204
assert.throws(() => {
205205
fs.copyFileSync(regularFile, path.join(blockedFolder, 'any-file'));
206-
}, common.expectsError({
206+
},{
207207
code: 'ERR_ACCESS_DENIED',
208208
permission: 'FileSystemWrite',
209209
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
210-
}));
210+
});
211211
assert.throws(() => {
212212
fs.copyFileSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
213-
}, common.expectsError({
213+
},{
214214
code: 'ERR_ACCESS_DENIED',
215215
permission: 'FileSystemWrite',
216216
resource: path.toNamespacedPath(path.join(absoluteProtectedFolder, 'any-file')),
217-
}));
217+
});
218218
}
219219

220220
// fs.cp
221221
{
222222
assert.throws(() => {
223223
fs.cpSync(regularFile, path.join(blockedFolder, 'any-file'));
224-
}, common.expectsError({
224+
},{
225225
code: 'ERR_ACCESS_DENIED',
226226
permission: 'FileSystemWrite',
227227
resource: path.toNamespacedPath(path.join(blockedFolder, 'any-file')),
228-
}));
228+
});
229229
assert.throws(() => {
230230
fs.cpSync(regularFile, path.join(relativeProtectedFolder, 'any-file'));
231-
}, common.expectsError({
231+
},{
232232
code: 'ERR_ACCESS_DENIED',
233233
permission: 'FileSystemWrite',
234234
resource: path.toNamespacedPath(path.join(absoluteProtectedFolder, 'any-file')),
235-
}));
235+
});
236236
}
237237

238238
// fs.rm
239239
{
240240
assert.throws(() => {
241241
fs.rmSync(blockedFolder, { recursive: true });
242-
}, common.expectsError({
242+
},{
243243
code: 'ERR_ACCESS_DENIED',
244244
permission: 'FileSystemWrite',
245245
resource: path.toNamespacedPath(blockedFolder),
246-
}));
246+
});
247247
assert.throws(() => {
248248
fs.rmSync(relativeProtectedFolder, { recursive: true });
249-
}, common.expectsError({
249+
},{
250250
code: 'ERR_ACCESS_DENIED',
251251
permission: 'FileSystemWrite',
252252
resource: path.toNamespacedPath(absoluteProtectedFolder),
253-
}));
253+
});
254254
}
255255

256256
// fs.open

0 commit comments

Comments
 (0)