mirror of
https://github.com/denoland/deno.git
synced 2024-12-24 16:19:12 -05:00
332 lines
10 KiB
TypeScript
332 lines
10 KiB
TypeScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
|
import {
|
|
assertEquals,
|
|
assertThrows,
|
|
assertThrowsAsync,
|
|
} from "../testing/asserts.ts";
|
|
import * as path from "../path/mod.ts";
|
|
import { move, moveSync } from "./move.ts";
|
|
import { ensureFile, ensureFileSync } from "./ensure_file.ts";
|
|
import { ensureDir, ensureDirSync } from "./ensure_dir.ts";
|
|
import { exists, existsSync } from "./exists.ts";
|
|
|
|
const testdataDir = path.resolve("fs", "testdata");
|
|
|
|
Deno.test(async function moveDirectoryIfSrcNotExists(): Promise<void> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_1");
|
|
const destDir = path.join(testdataDir, "move_test_dest_1");
|
|
// if src directory not exist
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcDir, destDir);
|
|
}
|
|
);
|
|
});
|
|
|
|
Deno.test(async function moveDirectoryIfDestNotExists(): Promise<void> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_2");
|
|
const destDir = path.join(testdataDir, "move_test_dest_2");
|
|
|
|
await Deno.mkdir(srcDir, { recursive: true });
|
|
|
|
// if dest directory not exist
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcDir, destDir);
|
|
throw new Error("should not throw error");
|
|
},
|
|
Error,
|
|
"should not throw error"
|
|
);
|
|
|
|
await Deno.remove(destDir);
|
|
});
|
|
|
|
Deno.test(async function moveFileIfSrcNotExists(): Promise<void> {
|
|
const srcFile = path.join(testdataDir, "move_test_src_3", "test.txt");
|
|
const destFile = path.join(testdataDir, "move_test_dest_3", "test.txt");
|
|
|
|
// if src directory not exist
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcFile, destFile);
|
|
}
|
|
);
|
|
});
|
|
|
|
Deno.test(async function moveFileIfDestExists(): Promise<void> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_4");
|
|
const destDir = path.join(testdataDir, "move_test_dest_4");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
const destContent = new TextEncoder().encode("dest");
|
|
|
|
// make sure files exists
|
|
await Promise.all([ensureFile(srcFile), ensureFile(destFile)]);
|
|
|
|
// write file content
|
|
await Promise.all([
|
|
Deno.writeFile(srcFile, srcContent),
|
|
Deno.writeFile(destFile, destContent),
|
|
]);
|
|
|
|
// make sure the test file have been created
|
|
assertEquals(new TextDecoder().decode(await Deno.readFile(srcFile)), "src");
|
|
assertEquals(new TextDecoder().decode(await Deno.readFile(destFile)), "dest");
|
|
|
|
// move it without override
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcFile, destFile);
|
|
},
|
|
Error,
|
|
"dest already exists"
|
|
);
|
|
|
|
// move again with overwrite
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcFile, destFile, { overwrite: true });
|
|
throw new Error("should not throw error");
|
|
},
|
|
Error,
|
|
"should not throw error"
|
|
);
|
|
|
|
assertEquals(await exists(srcFile), false);
|
|
assertEquals(new TextDecoder().decode(await Deno.readFile(destFile)), "src");
|
|
|
|
// clean up
|
|
await Promise.all([
|
|
Deno.remove(srcDir, { recursive: true }),
|
|
Deno.remove(destDir, { recursive: true }),
|
|
]);
|
|
});
|
|
|
|
Deno.test(async function moveDirectory(): Promise<void> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_5");
|
|
const destDir = path.join(testdataDir, "move_test_dest_5");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
|
|
await Deno.mkdir(srcDir, { recursive: true });
|
|
assertEquals(await exists(srcDir), true);
|
|
await Deno.writeFile(srcFile, srcContent);
|
|
|
|
await move(srcDir, destDir);
|
|
|
|
assertEquals(await exists(srcDir), false);
|
|
assertEquals(await exists(destDir), true);
|
|
assertEquals(await exists(destFile), true);
|
|
|
|
const destFileContent = new TextDecoder().decode(
|
|
await Deno.readFile(destFile)
|
|
);
|
|
assertEquals(destFileContent, "src");
|
|
|
|
await Deno.remove(destDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(async function moveIfSrcAndDestDirectoryExistsAndOverwrite(): Promise<
|
|
void
|
|
> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_6");
|
|
const destDir = path.join(testdataDir, "move_test_dest_6");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
const destContent = new TextEncoder().encode("dest");
|
|
|
|
await Promise.all([
|
|
Deno.mkdir(srcDir, { recursive: true }),
|
|
Deno.mkdir(destDir, { recursive: true }),
|
|
]);
|
|
assertEquals(await exists(srcDir), true);
|
|
assertEquals(await exists(destDir), true);
|
|
await Promise.all([
|
|
Deno.writeFile(srcFile, srcContent),
|
|
Deno.writeFile(destFile, destContent),
|
|
]);
|
|
|
|
await move(srcDir, destDir, { overwrite: true });
|
|
|
|
assertEquals(await exists(srcDir), false);
|
|
assertEquals(await exists(destDir), true);
|
|
assertEquals(await exists(destFile), true);
|
|
|
|
const destFileContent = new TextDecoder().decode(
|
|
await Deno.readFile(destFile)
|
|
);
|
|
assertEquals(destFileContent, "src");
|
|
|
|
await Deno.remove(destDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(async function moveIntoSubDir(): Promise<void> {
|
|
const srcDir = path.join(testdataDir, "move_test_src_7");
|
|
const destDir = path.join(srcDir, "nest");
|
|
|
|
await ensureDir(destDir);
|
|
|
|
await assertThrowsAsync(
|
|
async (): Promise<void> => {
|
|
await move(srcDir, destDir);
|
|
},
|
|
Error,
|
|
`Cannot move '${srcDir}' to a subdirectory of itself, '${destDir}'.`
|
|
);
|
|
await Deno.remove(srcDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(function moveSyncDirectoryIfSrcNotExists(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_1");
|
|
const destDir = path.join(testdataDir, "move_sync_test_dest_1");
|
|
// if src directory not exist
|
|
assertThrows((): void => {
|
|
moveSync(srcDir, destDir);
|
|
});
|
|
});
|
|
|
|
Deno.test(function moveSyncDirectoryIfDestNotExists(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_2");
|
|
const destDir = path.join(testdataDir, "move_sync_test_dest_2");
|
|
|
|
Deno.mkdirSync(srcDir, { recursive: true });
|
|
|
|
// if dest directory not exist
|
|
assertThrows(
|
|
(): void => {
|
|
moveSync(srcDir, destDir);
|
|
throw new Error("should not throw error");
|
|
},
|
|
Error,
|
|
"should not throw error"
|
|
);
|
|
|
|
Deno.removeSync(destDir);
|
|
});
|
|
|
|
Deno.test(function moveSyncFileIfSrcNotExists(): void {
|
|
const srcFile = path.join(testdataDir, "move_sync_test_src_3", "test.txt");
|
|
const destFile = path.join(testdataDir, "move_sync_test_dest_3", "test.txt");
|
|
|
|
// if src directory not exist
|
|
assertThrows((): void => {
|
|
moveSync(srcFile, destFile);
|
|
});
|
|
});
|
|
|
|
Deno.test(function moveSyncFileIfDestExists(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_4");
|
|
const destDir = path.join(testdataDir, "move_sync_test_dest_4");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
const destContent = new TextEncoder().encode("dest");
|
|
|
|
// make sure files exists
|
|
ensureFileSync(srcFile);
|
|
ensureFileSync(destFile);
|
|
|
|
// write file content
|
|
Deno.writeFileSync(srcFile, srcContent);
|
|
Deno.writeFileSync(destFile, destContent);
|
|
|
|
// make sure the test file have been created
|
|
assertEquals(new TextDecoder().decode(Deno.readFileSync(srcFile)), "src");
|
|
assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "dest");
|
|
|
|
// move it without override
|
|
assertThrows(
|
|
(): void => {
|
|
moveSync(srcFile, destFile);
|
|
},
|
|
Error,
|
|
"dest already exists"
|
|
);
|
|
|
|
// move again with overwrite
|
|
assertThrows(
|
|
(): void => {
|
|
moveSync(srcFile, destFile, { overwrite: true });
|
|
throw new Error("should not throw error");
|
|
},
|
|
Error,
|
|
"should not throw error"
|
|
);
|
|
|
|
assertEquals(existsSync(srcFile), false);
|
|
assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "src");
|
|
|
|
// clean up
|
|
Deno.removeSync(srcDir, { recursive: true });
|
|
Deno.removeSync(destDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(function moveSyncDirectory(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_5");
|
|
const destDir = path.join(testdataDir, "move_sync_test_dest_5");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
|
|
Deno.mkdirSync(srcDir, { recursive: true });
|
|
assertEquals(existsSync(srcDir), true);
|
|
Deno.writeFileSync(srcFile, srcContent);
|
|
|
|
moveSync(srcDir, destDir);
|
|
|
|
assertEquals(existsSync(srcDir), false);
|
|
assertEquals(existsSync(destDir), true);
|
|
assertEquals(existsSync(destFile), true);
|
|
|
|
const destFileContent = new TextDecoder().decode(Deno.readFileSync(destFile));
|
|
assertEquals(destFileContent, "src");
|
|
|
|
Deno.removeSync(destDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(function moveSyncIfSrcAndDestDirectoryExistsAndOverwrite(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_6");
|
|
const destDir = path.join(testdataDir, "move_sync_test_dest_6");
|
|
const srcFile = path.join(srcDir, "test.txt");
|
|
const destFile = path.join(destDir, "test.txt");
|
|
const srcContent = new TextEncoder().encode("src");
|
|
const destContent = new TextEncoder().encode("dest");
|
|
|
|
Deno.mkdirSync(srcDir, { recursive: true });
|
|
Deno.mkdirSync(destDir, { recursive: true });
|
|
assertEquals(existsSync(srcDir), true);
|
|
assertEquals(existsSync(destDir), true);
|
|
Deno.writeFileSync(srcFile, srcContent);
|
|
Deno.writeFileSync(destFile, destContent);
|
|
|
|
moveSync(srcDir, destDir, { overwrite: true });
|
|
|
|
assertEquals(existsSync(srcDir), false);
|
|
assertEquals(existsSync(destDir), true);
|
|
assertEquals(existsSync(destFile), true);
|
|
|
|
const destFileContent = new TextDecoder().decode(Deno.readFileSync(destFile));
|
|
assertEquals(destFileContent, "src");
|
|
|
|
Deno.removeSync(destDir, { recursive: true });
|
|
});
|
|
|
|
Deno.test(function moveSyncIntoSubDir(): void {
|
|
const srcDir = path.join(testdataDir, "move_sync_test_src_7");
|
|
const destDir = path.join(srcDir, "nest");
|
|
|
|
ensureDirSync(destDir);
|
|
|
|
assertThrows(
|
|
(): void => {
|
|
moveSync(srcDir, destDir);
|
|
},
|
|
Error,
|
|
`Cannot move '${srcDir}' to a subdirectory of itself, '${destDir}'.`
|
|
);
|
|
Deno.removeSync(srcDir, { recursive: true });
|
|
});
|