1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-29 16:30:56 -05:00
denoland-deno/js/files_test.ts

244 lines
7.3 KiB
TypeScript
Raw Normal View History

2019-01-21 14:03:30 -05:00
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { test, testPerm, assert, assertEquals } from "./test_util.ts";
test(function filesStdioFileDescriptors() {
assertEquals(Deno.stdin.rid, 0);
assertEquals(Deno.stdout.rid, 1);
assertEquals(Deno.stderr.rid, 2);
});
testPerm({ read: true }, async function filesCopyToStdout() {
const filename = "package.json";
const file = await Deno.open(filename);
2018-10-10 11:59:36 -04:00
assert(file.rid > 2);
const bytesWritten = await Deno.copy(Deno.stdout, file);
const fileSize = Deno.statSync(filename).len;
assertEquals(bytesWritten, fileSize);
console.log("bytes written", bytesWritten);
});
testPerm({ read: true }, async function filesToAsyncIterator() {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
let totalSize = 0;
for await (const buf of Deno.toAsyncIterator(file)) {
totalSize += buf.byteLength;
}
assertEquals(totalSize, 12);
});
2018-12-12 12:05:58 -05:00
2018-12-13 16:20:37 -05:00
testPerm({ write: false }, async function writePermFailure() {
const filename = "tests/hello.txt";
const writeModes: Deno.OpenMode[] = ["w", "a", "x"];
2018-12-13 16:20:37 -05:00
for (const mode of writeModes) {
let err;
try {
await Deno.open(filename, mode);
2018-12-13 16:20:37 -05:00
} catch (e) {
err = e;
}
assert(!!err);
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
assertEquals(err.name, "PermissionDenied");
2018-12-13 16:20:37 -05:00
}
});
testPerm({ read: false }, async function readPermFailure() {
let caughtError = false;
try {
await Deno.open("package.json", "r");
} catch (e) {
caughtError = true;
assertEquals(e.kind, Deno.ErrorKind.PermissionDenied);
assertEquals(e.name, "PermissionDenied");
}
assert(caughtError);
});
testPerm({ write: false, read: false }, async function readWritePermFailure() {
const filename = "tests/hello.txt";
const writeModes: Deno.OpenMode[] = ["r+", "w+", "a+", "x+"];
for (const mode of writeModes) {
let err;
try {
await Deno.open(filename, mode);
} catch (e) {
err = e;
}
assert(!!err);
assertEquals(err.kind, Deno.ErrorKind.PermissionDenied);
assertEquals(err.name, "PermissionDenied");
}
});
testPerm({ read: true, write: true }, async function createFile() {
const tempDir = await Deno.makeTempDir();
2018-12-12 12:05:58 -05:00
const filename = tempDir + "/test.txt";
const f = await Deno.open(filename, "w");
let fileInfo = Deno.statSync(filename);
2018-12-12 12:05:58 -05:00
assert(fileInfo.isFile());
assert(fileInfo.len === 0);
const enc = new TextEncoder();
const data = enc.encode("Hello");
await f.write(data);
fileInfo = Deno.statSync(filename);
2018-12-12 12:05:58 -05:00
assert(fileInfo.len === 5);
f.close();
// TODO: test different modes
await Deno.remove(tempDir, { recursive: true });
2018-12-12 12:05:58 -05:00
});
testPerm({ read: true, write: true }, async function openModeWrite() {
const tempDir = Deno.makeTempDirSync();
2018-12-12 12:05:58 -05:00
const encoder = new TextEncoder();
const filename = tempDir + "hello.txt";
const data = encoder.encode("Hello world!\n");
let file = await Deno.open(filename, "w");
2018-12-12 12:05:58 -05:00
// assert file was created
let fileInfo = Deno.statSync(filename);
2018-12-12 12:05:58 -05:00
assert(fileInfo.isFile());
assertEquals(fileInfo.len, 0);
2018-12-12 12:05:58 -05:00
// write some data
await file.write(data);
fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.len, 13);
2018-12-12 12:05:58 -05:00
// assert we can't read from file
let thrown = false;
try {
const buf = new Uint8Array(20);
await file.read(buf);
} catch (e) {
thrown = true;
} finally {
assert(thrown, "'w' mode shouldn't allow to read file");
}
file.close();
// assert that existing file is truncated on open
file = await Deno.open(filename, "w");
2018-12-12 12:05:58 -05:00
file.close();
const fileSize = Deno.statSync(filename).len;
assertEquals(fileSize, 0);
await Deno.remove(tempDir, { recursive: true });
2018-12-12 12:05:58 -05:00
});
testPerm({ read: true, write: true }, async function openModeWriteRead() {
const tempDir = Deno.makeTempDirSync();
2018-12-12 12:05:58 -05:00
const encoder = new TextEncoder();
const filename = tempDir + "hello.txt";
const data = encoder.encode("Hello world!\n");
const file = await Deno.open(filename, "w+");
2018-12-12 12:05:58 -05:00
// assert file was created
let fileInfo = Deno.statSync(filename);
2018-12-12 12:05:58 -05:00
assert(fileInfo.isFile());
assertEquals(fileInfo.len, 0);
2018-12-12 12:05:58 -05:00
// write some data
await file.write(data);
fileInfo = Deno.statSync(filename);
assertEquals(fileInfo.len, 13);
2018-12-12 12:05:58 -05:00
const buf = new Uint8Array(20);
await file.seek(0, Deno.SeekMode.SEEK_START);
const result = await file.read(buf);
assertEquals(result.nread, 13);
file.close();
2018-12-12 12:05:58 -05:00
await Deno.remove(tempDir, { recursive: true });
2018-12-12 12:05:58 -05:00
});
testPerm({ read: true }, async function seekStart() {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
// Deliberately move 1 step forward
await file.read(new Uint8Array(1)); // "H"
// Skipping "Hello "
await file.seek(6, Deno.SeekMode.SEEK_START);
const buf = new Uint8Array(6);
await file.read(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncStart() {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
// Deliberately move 1 step forward
file.readSync(new Uint8Array(1)); // "H"
// Skipping "Hello "
file.seekSync(6, Deno.SeekMode.SEEK_START);
const buf = new Uint8Array(6);
file.readSync(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekCurrent() {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
// Deliberately move 1 step forward
await file.read(new Uint8Array(1)); // "H"
// Skipping "ello "
await file.seek(5, Deno.SeekMode.SEEK_CURRENT);
const buf = new Uint8Array(6);
await file.read(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncCurrent() {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
// Deliberately move 1 step forward
file.readSync(new Uint8Array(1)); // "H"
// Skipping "ello "
file.seekSync(5, Deno.SeekMode.SEEK_CURRENT);
const buf = new Uint8Array(6);
file.readSync(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekEnd() {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
await file.seek(-6, Deno.SeekMode.SEEK_END);
const buf = new Uint8Array(6);
await file.read(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, function seekSyncEnd() {
const filename = "tests/hello.txt";
const file = Deno.openSync(filename);
file.seekSync(-6, Deno.SeekMode.SEEK_END);
const buf = new Uint8Array(6);
file.readSync(buf);
const decoded = new TextDecoder().decode(buf);
assertEquals(decoded, "world!");
});
testPerm({ read: true }, async function seekMode() {
const filename = "tests/hello.txt";
const file = await Deno.open(filename);
let err;
try {
await file.seek(1, -1);
} catch (e) {
err = e;
}
assert(!!err);
assertEquals(err.kind, Deno.ErrorKind.InvalidSeekMode);
assertEquals(err.name, "InvalidSeekMode");
// We should still be able to read the file
// since it is still open.
let buf = new Uint8Array(1);
await file.read(buf); // "H"
assertEquals(new TextDecoder().decode(buf), "H");
});