From 151ce0266eb4de2c8fc600c81c192a5f791b6169 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Wed, 9 Oct 2019 17:10:09 -0400 Subject: Move everything into std subdir --- std/fs/move_test.ts | 330 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 330 insertions(+) create mode 100644 std/fs/move_test.ts (limited to 'std/fs/move_test.ts') diff --git a/std/fs/move_test.ts b/std/fs/move_test.ts new file mode 100644 index 000000000..bc73784b2 --- /dev/null +++ b/std/fs/move_test.ts @@ -0,0 +1,330 @@ +// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. +import { test } from "../testing/mod.ts"; +import { + assertEquals, + assertThrows, + assertThrowsAsync +} from "../testing/asserts.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"; +import * as path from "./path/mod.ts"; + +const testdataDir = path.resolve("fs", "testdata"); + +test(async function moveDirectoryIfSrcNotExists(): Promise { + 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 => { + await move(srcDir, destDir); + } + ); +}); + +test(async function moveDirectoryIfDestNotExists(): Promise { + const srcDir = path.join(testdataDir, "move_test_src_2"); + const destDir = path.join(testdataDir, "move_test_dest_2"); + + await Deno.mkdir(srcDir, true); + + // if dest directory not exist + await assertThrowsAsync( + async (): Promise => { + await move(srcDir, destDir); + throw new Error("should not throw error"); + }, + Error, + "should not throw error" + ); + + await Deno.remove(destDir); +}); + +test(async function moveFileIfSrcNotExists(): Promise { + 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 => { + await move(srcFile, destFile); + } + ); +}); + +test(async function moveFileIfDestExists(): Promise { + 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 => { + await move(srcFile, destFile); + }, + Error, + "dest already exists" + ); + + // move again with overwrite + await assertThrowsAsync( + async (): Promise => { + 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 }) + ]); +}); + +test(async function moveDirectory(): Promise { + 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, 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 }); +}); + +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, true), Deno.mkdir(destDir, 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 }); +}); + +test(async function moveIntoSubDir(): Promise { + const srcDir = path.join(testdataDir, "move_test_src_7"); + const destDir = path.join(srcDir, "nest"); + + await ensureDir(destDir); + + await assertThrowsAsync( + async (): Promise => { + await move(srcDir, destDir); + }, + Error, + `Cannot move '${srcDir}' to a subdirectory of itself, '${destDir}'.` + ); + await Deno.remove(srcDir, { recursive: true }); +}); + +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); + }); +}); + +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, 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); +}); + +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); + }); +}); + +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 }); +}); + +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, 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 }); +}); + +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, true); + Deno.mkdirSync(destDir, 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 }); +}); + +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 }); +}); -- cgit v1.2.3 From 93f7f00c956c14620ef031626f124b57397ca867 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Wed, 9 Oct 2019 17:22:22 -0400 Subject: Run deno_std tests in github actions --- std/fs/move_test.ts | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) (limited to 'std/fs/move_test.ts') diff --git a/std/fs/move_test.ts b/std/fs/move_test.ts index bc73784b2..fae951e1f 100644 --- a/std/fs/move_test.ts +++ b/std/fs/move_test.ts @@ -182,9 +182,11 @@ 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); - }); + assertThrows( + (): void => { + moveSync(srcDir, destDir); + } + ); }); test(function moveSyncDirectoryIfDestNotExists(): void { @@ -211,9 +213,11 @@ test(function moveSyncFileIfSrcNotExists(): void { const destFile = path.join(testdataDir, "move_sync_test_dest_3", "test.txt"); // if src directory not exist - assertThrows((): void => { - moveSync(srcFile, destFile); - }); + assertThrows( + (): void => { + moveSync(srcFile, destFile); + } + ); }); test(function moveSyncFileIfDestExists(): void { -- cgit v1.2.3