1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
// Copyright 2018 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEqual } from "./test_util.ts";
import * as deno from "deno";
testPerm({ env: true }, async function envSuccess() {
const env = deno.env();
assert(env !== null);
env.test_var = "Hello World";
const newEnv = deno.env();
assertEqual(env.test_var, newEnv.test_var);
});
test(async function envFailure() {
let caughtError = false;
try {
const env = deno.env();
} catch (err) {
caughtError = true;
// TODO assert(err instanceof deno.PermissionDenied).
assertEqual(err.name, "deno.PermissionDenied");
}
assert(caughtError);
});
// TODO Add tests for modified, accessed, and created fields once there is a way
// to create temp files.
test(async function statSyncSuccess() {
const packageInfo = deno.statSync("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
const testingInfo = deno.statSync("testing");
assert(testingInfo.isDirectory());
assert(!testingInfo.isSymlink());
const srcInfo = deno.statSync("src");
assert(srcInfo.isDirectory());
assert(!srcInfo.isSymlink());
});
test(async function statSyncNotFound() {
let caughtError = false;
let badInfo;
try {
badInfo = deno.statSync("bad_file_name");
} catch (err) {
caughtError = true;
// TODO assert(err instanceof deno.NotFound).
assert(err);
assertEqual(err.name, "deno.NotFound");
}
assert(caughtError);
assertEqual(badInfo, undefined);
});
test(async function lstatSyncSuccess() {
const packageInfo = deno.lstatSync("package.json");
assert(packageInfo.isFile());
assert(!packageInfo.isSymlink());
const testingInfo = deno.lstatSync("testing");
assert(!testingInfo.isDirectory());
assert(testingInfo.isSymlink());
const srcInfo = deno.lstatSync("src");
assert(srcInfo.isDirectory());
assert(!srcInfo.isSymlink());
});
test(async function lstatSyncNotFound() {
let caughtError = false;
let badInfo;
try {
badInfo = deno.lstatSync("bad_file_name");
} catch (err) {
caughtError = true;
// TODO assert(err instanceof deno.NotFound).
assert(err);
assertEqual(err.name, "deno.NotFound");
}
assert(caughtError);
assertEqual(badInfo, undefined);
});
test(async function readFileSyncSuccess() {
const data = deno.readFileSync("package.json");
if (!data.byteLength) {
throw Error(
`Expected positive value for data.byteLength ${data.byteLength}`
);
}
const decoder = new TextDecoder("utf-8");
const json = decoder.decode(data);
const pkg = JSON.parse(json);
assertEqual(pkg.name, "deno");
});
/* TODO We should be able to catch specific types.
test(function tests_readFileSync_NotFound() {
let caughtError = false;
let data;
try {
data = deno.readFileSync("bad_filename");
} catch (e) {
caughtError = true;
assert(e instanceof deno.NotFound);
}
assert(caughtError);
assert(data === undefined);
});
*/
testPerm({ write: true }, function writeFileSyncSuccess() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = deno.makeTempDirSync() + "/test.txt";
deno.writeFileSync(filename, data, 0o666);
const dataRead = deno.readFileSync(filename);
const dec = new TextDecoder("utf-8");
const actual = dec.decode(dataRead);
assertEqual("Hello", actual);
});
// For this test to pass we need --allow-write permission.
// Otherwise it will fail with deno.PermissionDenied instead of deno.NotFound.
testPerm({ write: true }, function writeFileSyncFail() {
const enc = new TextEncoder();
const data = enc.encode("Hello");
const filename = "/baddir/test.txt";
// The following should fail because /baddir doesn't exist (hopefully).
let caughtError = false;
try {
deno.writeFileSync(filename, data);
} catch (e) {
caughtError = true;
// TODO assertEqual(e, deno.NotFound);
assertEqual(e.name, "deno.NotFound");
}
assert(caughtError);
});
testPerm({ write: true }, function makeTempDirSync() {
const dir1 = deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
const dir2 = deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
// Check that both dirs are different.
assert(dir1 != dir2);
for (const dir of [dir1, dir2]) {
// Check that the prefix and suffix are applied.
const lastPart = dir.replace(/^.*[\\\/]/, "");
assert(lastPart.startsWith("hello"));
assert(lastPart.endsWith("world"));
}
// Check that the `dir` option works.
const dir3 = deno.makeTempDirSync({ dir: dir1 });
assert(dir3.startsWith(dir1));
assert(/^[\\\/]/.test(dir3.slice(dir1.length)));
// Check that creating a temp dir inside a nonexisting directory fails.
let err;
try {
deno.makeTempDirSync({ dir: "/baddir" });
} catch (err_) {
err = err_;
}
// TODO assert(err instanceof deno.NotFound).
assert(err);
assertEqual(err.name, "deno.NotFound");
});
test(function makeTempDirSyncPerm() {
// makeTempDirSync should require write permissions (for now).
let err;
try {
deno.makeTempDirSync({ dir: "/baddir" });
} catch (err_) {
err = err_;
}
// TODO assert(err instanceof deno.PermissionDenied).
assert(err);
assertEqual(err.name, "deno.PermissionDenied");
});
testPerm({ write: true }, function mkdirSync() {
const path = deno.makeTempDirSync() + "/dir/subdir";
deno.mkdirSync(path);
const pathInfo = deno.statSync(path);
assert(pathInfo.isDirectory());
});
testPerm({ write: false }, function mkdDirSyncPerm() {
let err;
try {
const path = "/baddir";
deno.mkdirSync(path);
} catch (err_) {
err = err_;
}
// TODO assert(err instanceof deno.PermissionDenied).
assert(err);
assertEqual(err.name, "deno.PermissionDenied");
});
testPerm({ write: true }, function renameSync() {
const testDir = deno.makeTempDirSync() + "/test-rename";
const oldpath = testDir + "/oldpath";
const newpath = testDir + "/newpath";
deno.mkdirSync(oldpath);
deno.renameSync(oldpath, newpath);
const newPathInfo = deno.statSync(newpath);
assert(newPathInfo.isDirectory());
let caughtErr = false;
let oldPathInfo;
try {
oldPathInfo = deno.statSync(oldpath);
} catch (err) {
caughtErr = true;
// TODO assert(err instanceof deno.NotFound).
assert(err);
assertEqual(err.name, "deno.NotFound");
}
assert(caughtErr);
assertEqual(oldPathInfo, undefined);
});
test(function renameSyncPerm() {
let err;
try {
const oldpath = "/oldbaddir";
const newpath = "/newbaddir";
deno.renameSync(oldpath, newpath);
} catch (err_) {
err = err_;
}
// TODO assert(err instanceof deno.PermissionDenied).
assert(err);
assertEqual(err.name, "deno.PermissionDenied");
});
|
