test: add more test coverage

Author: skovy

src/files.ts

@@ -40,4 +40,5 @@ export const writeFile = (file: string, contents: string): void => {
 /**
  * Return an array of file paths that matches the given files string.
  */
-export const getAllFilesToTransform = (files: string) => glob.sync(files);
+export const getAllFilesToTransform = (files: string) =>
+  glob.sync(files, { nodir: true });

test/cli.test.ts

@@ -0,0 +1,5 @@
+describe('cli', () => {
+  it('should perform file transformations', () => {
+    // cli();
+  });
+});

test/files.test.ts

@@ -0,0 +1,85 @@
+import fs from 'fs';
+import path from 'path';
+import { getAllFilesToTransform, getFileInfo, writeFile } from '../src/files';
+
+describe('files', () => {
+  let fsWriteFileSync: jest.SpyInstance;
+  let consoleError: jest.SpyInstance;
+  let processExit: jest.SpyInstance;
+
+  beforeEach(() => {
+    fsWriteFileSync = jest.spyOn(fs, 'writeFileSync').mockImplementation();
+    consoleError = jest.spyOn(console, 'error').mockImplementation();
+    processExit = jest.spyOn(process, 'exit').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('#getFileInfo', () => {
+    it('should return file info for the file', () => {
+      const testFile = path.join(__dirname, 'css', 'a.css');
+      expect(getFileInfo(testFile)).toEqual({
+        path: testFile,
+        source: `.class {
+  margin: 42px;
+  color: blue;
+  padding-right: 10em;
+  background-color: rgba(0, 0, 0, 0.2);
+}
+`,
+      });
+      expect(consoleError).not.toHaveBeenCalled();
+      expect(processExit).not.toHaveBeenCalled();
+    });
+
+    it('should exit if an error occurs reading a file', () => {
+      const testFile = path.join(__dirname, 'css', 'totally-bogus.css');
+      getFileInfo(testFile);
+      expect(consoleError).toHaveBeenCalledTimes(1);
+      expect(processExit).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('#writeFile', () => {
+    it('should write the files contents', () => {
+      writeFile('./testing.css', '.class {}');
+      expect(fsWriteFileSync).toHaveBeenCalledTimes(1);
+      expect(fsWriteFileSync).toHaveBeenCalledWith(
+        './testing.css',
+        '.class {}'
+      );
+      expect(consoleError).not.toHaveBeenCalled();
+      expect(processExit).not.toHaveBeenCalled();
+    });
+
+    it('should print the error but not exit if an error occurs writing a file', () => {
+      fsWriteFileSync.mockImplementation(() => {
+        throw new Error('Cannot write to file.');
+      });
+
+      writeFile('./testing.css', '.class {}');
+      expect(consoleError).toHaveBeenCalledTimes(1);
+      expect(processExit).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('#getAllFilesToTransform', () => {
+    it('should expand the file path and return and array of resolved file paths', () => {
+      expect(getAllFilesToTransform('./test/**/*.css')).toEqual([
+        './test/css/a.css',
+        './test/css/b.css',
+      ]);
+      expect(getAllFilesToTransform('./test/css/*.css')).toEqual([
+        './test/css/a.css',
+        './test/css/b.css',
+      ]);
+    });
+
+    it('should ignore directories', () => {
+      expect(getAllFilesToTransform('./test')).toEqual([]);
+      expect(getAllFilesToTransform('./test/css')).toEqual([]);
+    });
+  });
+});

test/perform.test.ts

@@ -0,0 +1,9 @@
+// import { perform } from '../src/perform';
+
+describe('perform', () => {
+  describe('#perform', () => {
+    it('should process the files and perform transformations', () => {
+      // perform();
+    });
+  });
+});

test/transform.test.ts

@@ -4,15 +4,16 @@ import { validateTransform, loadTransform, Transform } from '../src/transform';
 jest.mock('bundle-require', () => ({ bundleRequire: jest.fn() }));
 
 describe('transform', () => {
-  let exit: jest.SpyInstance;
+  let consoleError: jest.SpyInstance;
+  let processExit: jest.SpyInstance;
 
   beforeEach(() => {
-    console.error = jest.fn();
-    exit = jest.spyOn(process, 'exit').mockImplementation();
+    consoleError = jest.spyOn(console, 'error').mockImplementation();
+    processExit = jest.spyOn(process, 'exit').mockImplementation();
   });
 
   afterEach(() => {
-    exit.mockRestore();
+    jest.restoreAllMocks();
   });
 
   describe('#validateTransform', () => {
@@ -26,25 +27,25 @@ describe('transform', () => {
       const twoArg: Transform = (_fileInfo, _api) => null;
       expect(validateTransform(twoArg)).toBe(twoArg);
 
-      expect(console.error).not.toHaveBeenCalled();
-      expect(exit).not.toHaveBeenCalled();
+      expect(consoleError).not.toHaveBeenCalled();
+      expect(processExit).not.toHaveBeenCalled();
     });
 
     it('should exit if an invalid transform is provided since there is no way to recover', () => {
-      expect(console.error).toHaveBeenCalledTimes(0);
-      expect(exit).toHaveBeenCalledTimes(0);
+      expect(consoleError).toHaveBeenCalledTimes(0);
+      expect(processExit).toHaveBeenCalledTimes(0);
 
       validateTransform(null);
-      expect(console.error).toHaveBeenCalledTimes(1);
-      expect(exit).toHaveBeenCalledTimes(1);
+      expect(consoleError).toHaveBeenCalledTimes(1);
+      expect(processExit).toHaveBeenCalledTimes(1);
 
       validateTransform(undefined);
-      expect(console.error).toHaveBeenCalledTimes(2);
-      expect(exit).toHaveBeenCalledTimes(2);
+      expect(consoleError).toHaveBeenCalledTimes(2);
+      expect(processExit).toHaveBeenCalledTimes(2);
 
       validateTransform((_fileInfo: any, _api: any, _invalid: any) => null);
-      expect(console.error).toHaveBeenCalledTimes(3);
-      expect(exit).toHaveBeenCalledTimes(3);
+      expect(consoleError).toHaveBeenCalledTimes(3);
+      expect(processExit).toHaveBeenCalledTimes(3);
     });
   });
 
@@ -58,8 +59,8 @@ describe('transform', () => {
       });
 
       expect(await loadTransform('./transform.ts')).toBe(transform);
-      expect(console.error).not.toHaveBeenCalled();
-      expect(exit).not.toHaveBeenCalled();
+      expect(consoleError).not.toHaveBeenCalled();
+      expect(processExit).not.toHaveBeenCalled();
     });
 
     it('should load the transform file and fallback to the default export', async () => {
@@ -70,8 +71,8 @@ describe('transform', () => {
       });
 
       expect(await loadTransform('./transform.ts')).toBe(transform);
-      expect(console.error).not.toHaveBeenCalled();
-      expect(exit).not.toHaveBeenCalled();
+      expect(consoleError).not.toHaveBeenCalled();
+      expect(processExit).not.toHaveBeenCalled();
     });
 
     it('should exit if an error occurs loading the transform file', async () => {
@@ -80,8 +81,8 @@ describe('transform', () => {
       );
 
       await loadTransform('./transform.ts');
-      expect(console.error).toHaveBeenCalledTimes(1);
-      expect(exit).toHaveBeenCalledTimes(1);
+      expect(consoleError).toHaveBeenCalledTimes(1);
+      expect(processExit).toHaveBeenCalledTimes(1);
     });
   });
 });