Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit 28c2bf3

Browse filesBrowse 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
Copy full SHA for 28c2bf3

File tree

Expand file treeCollapse file tree

1 file changed

+48
-48
lines changed
Open diff view settings
Filter options
Expand file treeCollapse file tree

1 file changed

+48
-48
lines changed
Open diff view settings
Collapse file

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

Copy file name to clipboardExpand all lines: test/fixtures/permission/fs-write.js
+48-48Lines 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 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.