Skip to content

Commit 28c2bf3

Browse files
AndresMorelostargos
AndresMorelos
authored and
targos
committed
test: remove unneeded common.expectsError for asserts
PR-URL: #51353 Reviewed-By: Luigi Pinca <luigipinca@gmail.com> Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com> Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com> Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
1 parent b9275d9 commit 28c2bf3

1 file changed

Lines changed: 48 additions & 48 deletions

File tree

‎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
conststream=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
returnnewPromise((_resolve,reject)=>{
6464
conststream=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
returnnewPromise((_resolve,reject)=>{
7575
conststream=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,newDate(),newDate(),()=>{});
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,newDate(),newDate(),()=>{});
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'),newDate(),newDate(),()=>{});
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,newDate(),newDate(),()=>{});
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)