test: begin improving tests

Author: skovy

.vscode/tasks.json

@@ -0,0 +1,14 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "test:watch",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "problemMatcher": []
+    }
+  ]
+}

package.json

@@ -19,6 +19,7 @@
     "start": "tsdx watch",
     "build": "tsup src/index.ts src/cli.ts --dts",
     "test": "tsdx test",
+    "test:watch": "tsdx test --watch",
     "lint": "tsdx lint",
     "prepare": "yarn build",
     "clean": "rimraf dist",
@@ -35,6 +36,10 @@
     "singleQuote": true,
     "trailingComma": "es5"
   },
+  "resolutions": {
+    "**/tsdx/jest": "27.4.7",
+    "**/tsdx/ts-jest": "27.1.3"
+  },
   "devDependencies": {
     "@types/glob": "^7.2.0",
     "@types/node": "^17.0.13",

src/api.ts

@@ -1,6 +1,9 @@
 import postcss, { Root } from 'postcss';
 
 export interface TransformAPI {
+  /**
+   * Parse a raw CSS string into an abstract syntax tree and return a PostCSS `Root` node.
+   */
   parse(source: string): Root;
 }
 

src/files.ts

@@ -13,6 +13,9 @@ export interface TransformFileInfo {
   source: string;
 }
 
+/**
+ * Construct file metadata given a file path.
+ */
 export const getFileInfo = (file: string): TransformFileInfo => {
   try {
     const source = fs.readFileSync(file, 'utf8').toString();
@@ -23,6 +26,9 @@ export const getFileInfo = (file: string): TransformFileInfo => {
   }
 };
 
+/**
+ * Write contents to the given file.
+ */
 export const writeFile = (file: string, contents: string): void => {
   try {
     fs.writeFileSync(file, contents);
@@ -31,4 +37,7 @@ 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);

src/index.ts

@@ -1,2 +1 @@
-export { traverse, Processors } from './traverse';
 export { Transform } from './transform';

src/transform.ts

@@ -23,8 +23,8 @@ export type Transform = (
 /**
  * Validate the general structure of the transform to catch simple errors.
  */
-const validateTransform = (transform: unknown): Transform => {
-  if (typeof transform === 'function') {
+export const validateTransform = (transform: unknown): Transform => {
+  if (typeof transform === 'function' && transform.length <= 2) {
     return transform as Transform;
   } else {
     console.error(

src/traverse/index.ts

@@ -0,0 +1,22 @@
+import { Declaration, Rule } from 'postcss';
+import { api } from '../src/api';
+
+describe('api', () => {
+  describe('#parse', () => {
+    it('should return the root node of an abstract syntax tree', () => {
+      const root = api.parse(`.class { color: orange; }`);
+
+      expect(root.type).toEqual('root');
+      expect(root.nodes.length).toEqual(1);
+
+      const rule = root.nodes[0] as Rule;
+      expect(rule.type).toEqual('rule');
+      expect(rule.nodes.length).toEqual(1);
+
+      const declaration = rule.nodes[0] as Declaration;
+      expect(declaration.type).toEqual('decl');
+      expect(declaration.prop).toEqual('color');
+      expect(declaration.value).toEqual('orange');
+    });
+  });
+});

test/api.test.ts

@@ -0,0 +1,87 @@
+import { bundleRequire } from 'bundle-require';
+import { validateTransform, loadTransform, Transform } from '../src/transform';
+
+jest.mock('bundle-require', () => ({ bundleRequire: jest.fn() }));
+
+describe('transform', () => {
+  let exit: jest.SpyInstance;
+
+  beforeEach(() => {
+    console.error = jest.fn();
+    exit = jest.spyOn(process, 'exit').mockImplementation();
+  });
+
+  afterEach(() => {
+    exit.mockRestore();
+  });
+
+  describe('#validateTransform', () => {
+    it('should return the transform when valid', () => {
+      const empty: Transform = () => null;
+      expect(validateTransform(empty)).toBe(empty);
+
+      const oneArg: Transform = _fileInfo => null;
+      expect(validateTransform(oneArg)).toBe(oneArg);
+
+      const twoArg: Transform = (_fileInfo, _api) => null;
+      expect(validateTransform(twoArg)).toBe(twoArg);
+
+      expect(console.error).not.toHaveBeenCalled();
+      expect(exit).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);
+
+      validateTransform(null);
+      expect(console.error).toHaveBeenCalledTimes(1);
+      expect(exit).toHaveBeenCalledTimes(1);
+
+      validateTransform(undefined);
+      expect(console.error).toHaveBeenCalledTimes(2);
+      expect(exit).toHaveBeenCalledTimes(2);
+
+      validateTransform((_fileInfo: any, _api: any, _invalid: any) => null);
+      expect(console.error).toHaveBeenCalledTimes(3);
+      expect(exit).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('#loadTransform', () => {
+    it('should load the transform file import the "transform" export', async () => {
+      const transform: Transform = () => null;
+      const def: Transform = () => null;
+
+      (bundleRequire as jest.Mock).mockResolvedValue({
+        mod: { transform, default: def },
+      });
+
+      expect(await loadTransform('./transform.ts')).toBe(transform);
+      expect(console.error).not.toHaveBeenCalled();
+      expect(exit).not.toHaveBeenCalled();
+    });
+
+    it('should load the transform file and fallback to the default export', async () => {
+      const transform: Transform = () => null;
+
+      (bundleRequire as jest.Mock).mockResolvedValue({
+        mod: { default: transform },
+      });
+
+      expect(await loadTransform('./transform.ts')).toBe(transform);
+      expect(console.error).not.toHaveBeenCalled();
+      expect(exit).not.toHaveBeenCalled();
+    });
+
+    it('should exit if an error occurs loading the transform file', async () => {
+      (bundleRequire as jest.Mock).mockRejectedValue(
+        new Error('Cannot find file.')
+      );
+
+      await loadTransform('./transform.ts');
+      expect(console.error).toHaveBeenCalledTimes(1);
+      expect(exit).toHaveBeenCalledTimes(1);
+    });
+  });
+});