refactor code structure; add tests

test/cases/compare_directories.test.ts → src/compareDirectories/compareDirectories.test.ts

@@ -1,8 +1,8 @@
 import * as path from 'path';
-import { compareDirectories } from '../../dist';
-import { FsEntry } from '../../dist/models';
-import expectedSourceEntries from '../resources/common/expected_source_fs_entries';
-import expectedTargetEntries from '../resources/common/expected_target_fs_entries';
+import expectedSourceEntries from '../../test/resources/common/expected_source_fs_entries';
+import expectedTargetEntries from '../../test/resources/common/expected_target_fs_entries';
+import { FsEntry } from '../models';
+import compareDirectories from './compareDirectories';
 
 function expectEqualEntries(fsEntries, expectedFsEntries) {
   expect(fsEntries.every((fsEntry) => fsEntry instanceof FsEntry)).toBe(true);
@@ -56,8 +56,8 @@ describe('compareDirectories', () => {
   });
 
   describe('when both paths corresponds to directories', () => {
-    const sourceDirPath = path.join(__dirname, '../resources/common/source');
-    const targetDirPath = path.join(__dirname, '../resources/common/target');
+    const sourceDirPath = path.join(__dirname, '../../test/resources/common/source');
+    const targetDirPath = path.join(__dirname, '../../test/resources/common/target');
 
     const expectedSourceOnlyEntries = expectedSourceEntries.filter(({ name }) => name.includes('added'));
     const expectedDifferentSourceEntries = expectedSourceEntries.filter(({ name }) => name.includes('modified'));
@@ -190,8 +190,8 @@ describe('compareDirectories', () => {
 
     describe('when entries have same name but different types (file or directory)', () => {
       const commonName = 'file_or_dir.txt';
-      const sourceDirPathForCurrentCase = path.join(__dirname, '../resources/file_and_dir_equal_name/source');
-      const targetDirPathForCurrentCase = path.join(__dirname, '../resources/file_and_dir_equal_name/target');
+      const sourceDirPathForCurrentCase = path.join(__dirname, '../../test/resources/file_and_dir_equal_name/source');
+      const targetDirPathForCurrentCase = path.join(__dirname, '../../test/resources/file_and_dir_equal_name/target');
 
       it('differs these entries', async () => {
         const sourceOnlyEntries = [];

src/compare_directories/compare_directories.ts → src/compareDirectories/compareDirectories.ts

@@ -1,10 +1,10 @@
-import iterateDirectoryChildren from '../iterate_directory_children';
+import iterateDirectoryChildren from '../iterateDirectoryChildren';
 import { FsEntry } from '../models';
 import { areFileContentsEqual } from '../utils/fs';
-import getMirroredFsEntry from './get_mirrored_fs_entry';
-import validateArgs from './validate_args';
+import getMirroredFsEntry from './getMirroredFsEntry';
+import validateArgs from './validateArgs';
 
-export default async function compareDirectories(
+const compareDirectories = async (
   sourceDirPath: string,
   targetDirPath: string,
   {
@@ -22,7 +22,7 @@ export default async function compareDirectories(
     skipContentComparison?: boolean,
     skipExcessNestedIterations?: boolean,
   } = {},
-) {
+): Promise<void> => {
   await validateArgs(
     sourceDirPath,
     targetDirPath,
@@ -88,4 +88,6 @@ export default async function compareDirectories(
       }
     }
   });
-}
+};
+
+export default compareDirectories;

src/compare_directories/get_mirrored_fs_entry.ts → src/compareDirectories/getMirroredFsEntry.ts

@@ -1,11 +1,11 @@
 import * as path from 'path';
+import { stat } from 'fs/promises';
 import { FsEntry } from '../models';
-import { stat } from '../utils/fs';
 
-export default async function getMirroredFsEntry(
+const getMirroredFsEntry = async (
   fsEntry: FsEntry,
   mirrorRootPath: string,
-): Promise<FsEntry> {
+): Promise<FsEntry> => {
   const mirroredFsEntryPath = path.join(mirrorRootPath, fsEntry.relativePath);
   let mirroredFsEntryStats;
 
@@ -26,4 +26,6 @@ export default async function getMirroredFsEntry(
     isFile: mirroredFsEntryStats.isFile(),
     size: mirroredFsEntryStats.size,
   });
-}
+};
+
+export default getMirroredFsEntry;

src/compareDirectories/index.ts

@@ -0,0 +1 @@
+export { default } from './compareDirectories';

src/compare_directories/validate_args.ts → src/compareDirectories/validateArgs.ts

@@ -1,6 +1,6 @@
-import { validateBooleanArg, validateDirPathArg, validateFunctionArg } from '../validations';
+import { validateBooleanArg, validateDirPathArg, validateFunctionArg } from '../utils/validations';
 
-export default async function validateArgs(
+const validateArgs = async (
   sourceDirPath: any,
   targetDirPath: any,
   onEachEntry: any,
@@ -9,7 +9,7 @@ export default async function validateArgs(
   onDifferentEntries: any,
   skipContentComparison: any,
   skipExcessNestedIterations: any,
-) {
+): Promise<void> => {
   await validateDirPathArg(sourceDirPath, 'Source directory');
   await validateDirPathArg(targetDirPath, 'Target directory');
 
@@ -20,4 +20,6 @@ export default async function validateArgs(
 
   validateBooleanArg(skipContentComparison, 'skipContentComparison');
   validateBooleanArg(skipExcessNestedIterations, 'skipExcessNestedIterations');
-}
+};
+
+export default validateArgs;

src/index.ts

@@ -1,3 +1,3 @@
-export { default as iterateDirectoryChildren } from './iterate_directory_children';
-export { default as compareDirectories } from './compare_directories';
+export { default as iterateDirectoryChildren } from './iterateDirectoryChildren';
+export { default as compareDirectories } from './compareDirectories';
 export { FsEntry } from './models';

src/iterateDirectoryChildren/index.ts

@@ -0,0 +1 @@
+export { default } from './iterateDirectoryChildren';

test/cases/iterate_directory_children.test.ts → src/iterateDirectoryChildren/iterateDirectoryChildren.test.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
-import { iterateDirectoryChildren } from '../../dist';
-import { FsEntry } from '../../dist/models';
-import expectedFsEntries from '../resources/common/expected_source_fs_entries';
+import { FsEntry } from '../models';
+import iterateDirectoryChildren from './iterateDirectoryChildren';
+import expectedFsEntries from '../../test/resources/common/expected_source_fs_entries';
 
 const callback = () => { };
 
@@ -45,7 +45,7 @@ describe('iterateDirectoryChildren', () => {
   });
 
   describe('when path corresponds to directory', () => {
-    const dirPath = path.join(__dirname, '../resources/common/source');
+    const dirPath = path.join(__dirname, '../../test/resources/common/source');
 
     describe('when callback is executed without rejections for each element', () => {
       let fsEntries;

src/iterateDirectoryChildren/iterateDirectoryChildren.ts

@@ -0,0 +1,13 @@
+import iterateDirectoryChildrenRecursive from './iterateDirectoryChildrenRecursive';
+import { OnEachChild } from './types';
+import validateArgs from './validateArgs';
+
+const iterateDirectoryChildren = async (
+  dirPath: string,
+  onEachChild: OnEachChild,
+): Promise<void> => {
+  await validateArgs(dirPath, onEachChild);
+  await iterateDirectoryChildrenRecursive(dirPath, null, onEachChild);
+};
+
+export default iterateDirectoryChildren;

src/iterate_directory_children/iterate_directory_children_recursive.ts → src/iterateDirectoryChildren/iterateDirectoryChildrenRecursive.ts

@@ -1,14 +1,14 @@
 import * as path from 'path';
+import { stat, readdir } from 'fs/promises';
 import { FsEntry } from '../models';
-import { iterateInSeries } from '../utils/array';
-import { stat, readdir } from '../utils/fs';
+import { iterateInSeries } from '../utils/iteration';
 import { OnEachChild } from './types';
 
-export default async function iterateDirectoryChildrenRecursive(
+const iterateDirectoryChildrenRecursive = async (
   absoluteDirPath: string,
   relativeDirPath: string,
   onEachChild: OnEachChild,
-) {
+): Promise<void> => {
   const entries = await readdir(absoluteDirPath);
 
   await iterateInSeries(entries, async (name: string) => {
@@ -38,4 +38,6 @@ export default async function iterateDirectoryChildrenRecursive(
       await iterateDirectoryChildrenRecursive(absolutePath, relativePath, onEachChild);
     }
   });
-}
+};
+
+export default iterateDirectoryChildrenRecursive;

src/iterateDirectoryChildren/validateArgs.ts

@@ -0,0 +1,11 @@
+import { validateDirPathArg, validateFunctionArg } from '../utils/validations';
+
+const validateArgs = async (dirPath: unknown, onEachChild: unknown): Promise<void> => {
+  await validateDirPathArg(dirPath, 'Directory');
+
+  validateFunctionArg(onEachChild, 'onEachChild', {
+    isRequired: true,
+  });
+};
+
+export default validateArgs;

test/cases/models/fs_entry.test.ts → src/models/FsEntry.test.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
-import { FsEntry } from '../../../dist';
+import FsEntry from './FsEntry';
 
-describe('FsEntry', () => {
+describe('models > FsEntry', () => {
   describe('constructor', () => {
     it('initializes instance with correct params', () => {
       const opts = {

src/models/fs_entry.ts → src/models/FsEntry.ts

@@ -1,4 +1,4 @@
-export default class FsEntry {
+class FsEntry {
   name: string;
 
   absolutePath: string;
@@ -37,3 +37,5 @@ export default class FsEntry {
     this.isFile = !isDirectory;
   }
 }
+
+export default FsEntry;

src/models/index.ts

@@ -1,2 +1,2 @@
 // eslint-disable-next-line import/prefer-default-export
-export { default as FsEntry } from './fs_entry';
+export { default as FsEntry } from './FsEntry';

test/cases/utils/fs/are_file_contents_equal.test.ts → src/utils/fs/areFileContentsEqual.test.ts

@@ -1,11 +1,9 @@
 import * as path from 'path';
-import { areFileContentsEqual } from '../../../../dist/utils/fs';
+import areFileContentsEqual from './areFileContentsEqual';
 
-function getFilePath(fileName: string): string {
-  return path.join(__dirname, `../../../resources/common/${fileName}`);
-}
+const getFilePath = (fileName: string): string => path.join(__dirname, `../../../test/resources/common/${fileName}`);
 
-describe('areFileContentsEqual', () => {
+describe('utils > fs > areFileContentsEqual', () => {
   describe('when files have equal contents', () => {
     const filePath1 = getFilePath('source/file3.txt');
     const filePath2 = getFilePath('target/file3.txt');

src/utils/fs/areFileContentsEqual.ts

@@ -0,0 +1,11 @@
+import { createReadStream } from 'fs';
+import * as streamEqual from 'stream-equal';
+
+const areFileContentsEqual = async (filePath1: string, filePath2: string): Promise<boolean> => {
+  const stream1 = createReadStream(filePath1);
+  const stream2 = createReadStream(filePath2);
+
+  return streamEqual(stream1, stream2);
+};
+
+export default areFileContentsEqual;

src/utils/fs/index.ts

@@ -0,0 +1,2 @@
+export { default as areFileContentsEqual } from './areFileContentsEqual';
+export { default as isDirExist } from './isDirExist';

test/cases/utils/fs/dir_exists.test.ts → src/utils/fs/isDirExist.test.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
-import { isDirExist } from '../../../../dist/utils/fs';
+import isDirExist from './isDirExist';
 
-describe('dirExist', () => {
+describe('utils > fs > dirExist', () => {
   describe('when path does not exist', () => {
     const invalidPath = path.join(__dirname, 'invalid/path');
 

src/utils/fs/isDirExist.ts

@@ -0,0 +1,12 @@
+import { stat } from 'fs/promises';
+
+const isDirExist = async (path: string): Promise<boolean> => {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch (err) {
+    return false;
+  }
+};
+
+export default isDirExist;

src/utils/iteration/index.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export { default as iterateInSeries } from './iterateInSeries';