mirror of
https://github.com/denoland/deno.git
synced 2024-12-25 08:39:09 -05:00
348 lines
8.7 KiB
TypeScript
348 lines
8.7 KiB
TypeScript
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
||
import {
|
||
test,
|
||
testPerm,
|
||
assert,
|
||
assertEquals,
|
||
assertNotEquals,
|
||
assertThrows
|
||
} from "./test_util.ts";
|
||
|
||
testPerm({ env: true }, function envSuccess(): void {
|
||
const env = Deno.env();
|
||
assert(env !== null);
|
||
// eslint-disable-next-line @typescript-eslint/camelcase
|
||
env.test_var = "Hello World";
|
||
const newEnv = Deno.env();
|
||
assertEquals(env.test_var, newEnv.test_var);
|
||
assertEquals(Deno.env("test_var"), env.test_var);
|
||
});
|
||
|
||
testPerm({ env: true }, function envNotFound(): void {
|
||
const r = Deno.env("env_var_does_not_exist!");
|
||
assertEquals(r, undefined);
|
||
});
|
||
|
||
test(function envPermissionDenied1(): void {
|
||
let err;
|
||
try {
|
||
Deno.env();
|
||
} catch (e) {
|
||
err = e;
|
||
}
|
||
assertNotEquals(err, undefined);
|
||
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
|
||
assertEquals(err.name, "PermissionDenied");
|
||
});
|
||
|
||
test(function envPermissionDenied2(): void {
|
||
let err;
|
||
try {
|
||
Deno.env("PATH");
|
||
} catch (e) {
|
||
err = e;
|
||
}
|
||
assertNotEquals(err, undefined);
|
||
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
|
||
assertEquals(err.name, "PermissionDenied");
|
||
});
|
||
|
||
if (Deno.build.os === "win") {
|
||
// This test verifies that on Windows, environment variables are
|
||
// case-insensitive. Case normalization needs be done using the collation
|
||
// that Windows uses, rather than naively using String.toLowerCase().
|
||
testPerm({ env: true, run: true }, async function envCaseInsensitive() {
|
||
// Utility function that runs a Deno subprocess with the environment
|
||
// specified in `inputEnv`. The subprocess reads the environment variables
|
||
// which are in the keys of `expectedEnv` and writes them to stdout as JSON.
|
||
// It is then verified that these match with the values of `expectedEnv`.
|
||
const checkChildEnv = async (inputEnv, expectedEnv): Promise<void> => {
|
||
const src = `
|
||
console.log(
|
||
${JSON.stringify(Object.keys(expectedEnv))}.map(k => Deno.env(k))
|
||
)`;
|
||
const proc = Deno.run({
|
||
args: [Deno.execPath(), "eval", src],
|
||
env: inputEnv,
|
||
stdout: "piped"
|
||
});
|
||
const status = await proc.status();
|
||
assertEquals(status.success, true);
|
||
const expectedValues = Object.values(expectedEnv);
|
||
const actualValues = JSON.parse(
|
||
new TextDecoder().decode(await proc.output())
|
||
);
|
||
assertEquals(actualValues, expectedValues);
|
||
};
|
||
|
||
assertEquals(Deno.env("path"), Deno.env("PATH"));
|
||
assertEquals(Deno.env("Path"), Deno.env("PATH"));
|
||
|
||
// Check 'foo', 'Foo' and 'Foo' are case folded.
|
||
await checkChildEnv({ foo: "X" }, { foo: "X", Foo: "X", FOO: "X" });
|
||
|
||
// Check that 'µ' and 'Μ' are not case folded.
|
||
const lc1 = "µ";
|
||
const uc1 = lc1.toUpperCase();
|
||
assertNotEquals(lc1, uc1);
|
||
await checkChildEnv(
|
||
{ [lc1]: "mu", [uc1]: "MU" },
|
||
{ [lc1]: "mu", [uc1]: "MU" }
|
||
);
|
||
|
||
// Check that 'dž' and 'DŽ' are folded, but 'Dž' is preserved.
|
||
const c2 = "Dž";
|
||
const lc2 = c2.toLowerCase();
|
||
const uc2 = c2.toUpperCase();
|
||
assertNotEquals(c2, lc2);
|
||
assertNotEquals(c2, uc2);
|
||
await checkChildEnv(
|
||
{ [c2]: "Dz", [lc2]: "dz" },
|
||
{ [c2]: "Dz", [lc2]: "dz", [uc2]: "dz" }
|
||
);
|
||
await checkChildEnv(
|
||
{ [c2]: "Dz", [uc2]: "DZ" },
|
||
{ [c2]: "Dz", [uc2]: "DZ", [lc2]: "DZ" }
|
||
);
|
||
});
|
||
}
|
||
|
||
test(function osPid(): void {
|
||
console.log("pid", Deno.pid);
|
||
assert(Deno.pid > 0);
|
||
});
|
||
|
||
test(function osIsTTYSmoke(): void {
|
||
console.log(Deno.isTTY());
|
||
});
|
||
|
||
testPerm({ env: true }, function homeDir(): void {
|
||
assertNotEquals(Deno.homeDir(), "");
|
||
});
|
||
|
||
testPerm({ env: false }, function homeDirPerm(): void {
|
||
let caughtError = false;
|
||
try {
|
||
Deno.homeDir();
|
||
} catch (err) {
|
||
caughtError = true;
|
||
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
|
||
assertEquals(err.name, "PermissionDenied");
|
||
}
|
||
assert(caughtError);
|
||
});
|
||
|
||
testPerm({ env: true }, function getUserDir(): void {
|
||
type supportOS = "mac" | "win" | "linux";
|
||
|
||
interface Runtime {
|
||
os: supportOS;
|
||
shouldHaveValue: boolean;
|
||
}
|
||
|
||
interface Scenes {
|
||
name: string;
|
||
fn: string;
|
||
runtime: Runtime[];
|
||
}
|
||
|
||
const scenes: Scenes[] = [
|
||
{
|
||
name: "config",
|
||
fn: "configDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: true }
|
||
]
|
||
},
|
||
{
|
||
name: "cache",
|
||
fn: "cacheDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: true }
|
||
]
|
||
},
|
||
{
|
||
name: "data",
|
||
fn: "dataDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: true }
|
||
]
|
||
},
|
||
{
|
||
name: "data local",
|
||
fn: "dataLocalDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: true }
|
||
]
|
||
},
|
||
{
|
||
name: "audio",
|
||
fn: "audioDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "desktop",
|
||
fn: "desktopDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "document",
|
||
fn: "documentDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "download",
|
||
fn: "downloadDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "font",
|
||
fn: "fontDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: false },
|
||
{ os: "linux", shouldHaveValue: true }
|
||
]
|
||
},
|
||
{
|
||
name: "picture",
|
||
fn: "pictureDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "public",
|
||
fn: "publicDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "template",
|
||
fn: "templateDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: false },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
},
|
||
{
|
||
name: "video",
|
||
fn: "videoDir",
|
||
runtime: [
|
||
{ os: "mac", shouldHaveValue: true },
|
||
{ os: "win", shouldHaveValue: true },
|
||
{ os: "linux", shouldHaveValue: false }
|
||
]
|
||
}
|
||
];
|
||
|
||
for (const s of scenes) {
|
||
console.log(`test Deno.${s.fn}()`);
|
||
const fn = Deno[s.fn];
|
||
|
||
for (const r of s.runtime) {
|
||
if (Deno.build.os !== r.os) continue;
|
||
if (r.shouldHaveValue) {
|
||
assertNotEquals(fn(), "");
|
||
} else {
|
||
// if not support your platform. it should throw an error
|
||
assertThrows(
|
||
() => fn(),
|
||
Deno.DenoError,
|
||
`Could not get user ${s.name} directory.`
|
||
);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
testPerm({}, function getUserDirWithoutPermission(): void {
|
||
const funcs: string[] = [
|
||
"configDir",
|
||
"cacheDir",
|
||
"dataDir",
|
||
"dataLocalDir",
|
||
"audioDir",
|
||
"desktopDir",
|
||
"documentDir",
|
||
"downloadDir",
|
||
"fontDir",
|
||
"pictureDir",
|
||
"publicDir",
|
||
"templateDir",
|
||
"videoDir"
|
||
];
|
||
|
||
for (const fnName of funcs) {
|
||
console.log(`test Deno.${fnName}()`);
|
||
const fn = Deno[fnName];
|
||
|
||
assertThrows(
|
||
() => fn(),
|
||
Deno.DenoError,
|
||
`run again with the --allow-env flag`
|
||
);
|
||
}
|
||
});
|
||
|
||
testPerm({ env: true }, function execPath(): void {
|
||
assertNotEquals(Deno.execPath(), "");
|
||
});
|
||
|
||
testPerm({ env: false }, function execPathPerm(): void {
|
||
let caughtError = false;
|
||
try {
|
||
Deno.execPath();
|
||
} catch (err) {
|
||
caughtError = true;
|
||
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
|
||
assertEquals(err.name, "PermissionDenied");
|
||
}
|
||
assert(caughtError);
|
||
});
|
||
|
||
testPerm({ env: true }, function hostnameDir(): void {
|
||
assertNotEquals(Deno.hostname(), "");
|
||
});
|
||
|
||
testPerm({ env: false }, function hostnamePerm(): void {
|
||
let caughtError = false;
|
||
try {
|
||
Deno.hostname();
|
||
} catch (err) {
|
||
caughtError = true;
|
||
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
|
||
assertEquals(err.name, "PermissionDenied");
|
||
}
|
||
assert(caughtError);
|
||
});
|