test: first fs.ts tests of exists functions

Author: Craig Doremus

shared/fs.ts

@@ -2,7 +2,7 @@ import { dirname } from 'https://deno.land/[email protected]/path/mod.ts'
 import { ensureDir } from 'https://deno.land/[email protected]/fs/ensure_dir.ts'
 
 /* check whether or not the given path exists as a directory. */
-export async function existsDir(path: string): Promise<boolean> {
+export async function existsDir(path: string): Promise<boolean | Error> {
   try {
     const fi = await Deno.lstat(path)
     if (fi.isDirectory) {
@@ -18,7 +18,7 @@ export async function existsDir(path: string): Promise<boolean> {
 }
 
 /* check whether or not the given path exists as a directory. */
-export function existsDirSync(path: string) {
+export function existsDirSync(path: string): boolean | Error {
   try {
     const fi = Deno.lstatSync(path)
     if (fi.isDirectory) {
@@ -34,7 +34,7 @@ export function existsDirSync(path: string) {
 }
 
 /* check whether or not the given path exists as regular file. */
-export async function existsFile(path: string): Promise<boolean> {
+export async function existsFile(path: string): Promise<boolean | Error> {
   try {
     const fi = await Deno.lstat(path)
     if (fi.isFile) {
@@ -50,7 +50,7 @@ export async function existsFile(path: string): Promise<boolean> {
 }
 
 /* check whether or not the given path exists as regular file. */
-export function existsFileSync(path: string) {
+export function existsFileSync(path: string): boolean {
   try {
     const fi = Deno.lstatSync(path)
     if (fi.isFile) {
@@ -73,7 +73,7 @@ export async function ensureTextFile(name: string, content: string): Promise<voi
 }
 
 /** remove the file if it exists. */
-export async function lazyRemove(name: string, options?: { recursive?: boolean }): Promise<void> {
+export async function lazyRemove(name: string, options?: { recursive?: boolean }): Promise<void | Error> {
   try {
     await Deno.remove(name, options)
   } catch (err) {

shared/fs_test.ts

@@ -0,0 +1,136 @@
+import { assert, assertEquals, assertThrows } from 'https://deno.land/[email protected]/testing/asserts.ts'
+import { SEP } from "https://deno.land/[email protected]/path/separator.ts"
+import { existsDir, existsDirSync, existsFile, existsFileSync } from './fs.ts'
+
+
+Deno.test(`fs existsDirSync`, () => {
+    // true test cases
+    assert(existsDirSync(getAbsolutePath(`.${SEP}shared`)))
+    assert(existsDir(getAbsolutePath(getStandardFolder())))
+    // false test cases
+    assertEquals(existsDirSync(getAbsolutePath(`.${SEP}foobar`)), false)
+    assertEquals(existsDirSync(getAbsolutePath(`.${SEP}shared${SEP}fs.ts`)), false)
+    assertEquals(existsDirSync(getAbsolutePath('&*^--%$#@')), false)
+    // error test cases
+    assertThrows(() => existsDirSync({} as string), Error)
+})
+
+Deno.test(`fs async existsDir`, async () => {
+    // true test cases
+    assertEquals(await existsDir(getAbsolutePath(getStandardFolder())), true)
+    assertEquals(await existsDir(getAbsolutePath(`.${SEP}shared`)), true)
+    // false test cases
+    assertEquals(await existsDir(getAbsolutePath(`.${SEP}foobar`)), false)
+    assertEquals(await existsDir(getAbsolutePath(`.${SEP}shared${SEP}fs.ts`)), false)
+    assertEquals(await existsDir(getAbsolutePath('&*^--%$#@')), false)
+    // error test cases
+    existsDir({} as string).then(err => {
+        assert(err instanceof Error)
+    }).catch(e => console.error(e))
+})
+
+Deno.test(`fs existsFileSync`, () => {
+    // true test cases
+    assert(existsFileSync(getAbsolutePath(`.${SEP}shared${SEP}fs.ts`)))
+    // false test cases
+    assert(!existsFileSync(getAbsolutePath(`.${SEP}shared`)))
+    assert(!existsFileSync(getAbsolutePath(`.${SEP}shared${SEP}baz.ts`)))
+    // error test cases
+    assertThrows(() => existsDirSync({} as string), Error)
+})
+
+Deno.test(`fs async existsFile`, async () => {
+    // true test cases
+    assert(await existsFile(getAbsolutePath(`.${SEP}shared${SEP}fs.ts`)))
+    // false test cases
+    assertEquals(await existsFile(getAbsolutePath(`.${SEP}shared${SEP}foobar.ts`)), false)
+    // error test cases
+    existsDir({} as string).then(err => {
+        assert(err instanceof Error)
+    }).catch(e => console.error(e))
+})
+
+Deno.test('ensureTextFile', () => {
+
+})
+
+Deno.test('lazyRemove', () => {
+
+})
+
+/**
+ * Test of local function getAbsolutePath
+ */
+Deno.test('getAbsolutePath', () => {
+    // folder
+    let path = 'shared'
+    let absPath = getAbsolutePath(path)
+    assert(Deno.lstatSync(absPath).isDirectory)
+    path = `.${SEP}shared`
+    absPath = getAbsolutePath(path)
+    assert(Deno.lstatSync(absPath).isDirectory)
+    // file
+    path = `shared${SEP}fs.ts`
+    absPath = getAbsolutePath(path)
+    assert(Deno.lstatSync(absPath).isFile)
+    path = `.${SEP}shared${SEP}fs.ts`
+    absPath = getAbsolutePath(path)
+    assert(Deno.lstatSync(absPath).isFile)
+})
+
+/**
+ * Returns an operating system-specific
+ * example folder.
+ * @returns 'C:\Program Files' for Windows or
+ *  '/tmp' for unix-based operating systems
+ */
+const getStandardFolder = () => {
+    return Deno.build.os === 'windows' ? 'C:\Program Files' : '/tmp'
+}
+
+
+/**
+ * This function is designed to be used in this module
+ * for test cases involving a file or directory. It
+ * takes a path to a folder or file and converts it to an
+ * absolute path. Designed to be os-agnostic by using
+ * the SEP path separator from the Deno standard (std)
+ * library (separator module).
+ *
+ * <strong>Note:</strong> This function might need to
+ * be modified when the test is run in a CI/CD environment
+ * depending where the tests are run. The current
+ * implementation assumes that the tests are being
+ * run from the repo's root folder.
+ *
+ * @param path relative or absolute path string to a folder
+ *  or file. If the string starts with a operating-system
+ *  agnostic slash, then it is assumed to be a full path;
+ *  if the path starts with a dot slash (./) or no
+ *  slash, then the path argument is assumed to be
+ *  a relative path
+ * @returns the full path to the folder or file
+ */
+const getAbsolutePath = (path: string): string => {
+    const cwd = Deno.cwd()
+    let fullRelativePath
+    let absolutePath
+    if (path.startsWith(`.${SEP}`)) { // dot slash
+        // path == local relative path
+        fullRelativePath = path.substring(1)
+        absolutePath = `${cwd}${fullRelativePath}`
+        // absolutePath = Deno.realPathSync(path)
+        // console.log('REAL PATH: ', absolutePath)
+    } else if (path.startsWith(SEP)) { // slash
+        // path === absolute path
+        absolutePath = Deno.realPathSync(path)
+    } else if (path.startsWith('C:\\')) { // windows full path
+        // path === absolute path
+        absolutePath = Deno.realPathSync(path)
+    } else { // no dot or slash at start of path
+        // path == local relative path
+        fullRelativePath = path
+        absolutePath = `${cwd}${SEP}${fullRelativePath}`
+    }
+    return absolutePath
+}