test config

package.json

@@ -58,10 +58,13 @@
     "cross-env": "^5.2.0",
     "eslint": "^5.10.0",
     "eslint-config-google": "^0.11.0",
+    "lodash": "^4.17.11",
     "mocha": "^5.2.0",
     "npm-run-all": "^4.1.5",
     "nyc": "^13.1.0",
-    "rimraf": "^2.6.2"
+    "rimraf": "^2.6.2",
+    "sinon": "^7.2.2",
+    "sinon-chai": "^3.3.0"
   },
   "dependencies": {
     "inquirer": "^6.2.1",

src/schema.js

@@ -1,9 +1,14 @@
+import {requires, entry} from './utils';
+
 export class Schema {
   constructor(params) {
-    this.params = params;
+    requires(params.require);
+    this.entry = entry(params.entry);
   }
 
   generate() {
-    return this.params;
+    const documents = {};
+    this.entry(documents);
+    return documents;
   }
 }

src/utils.js

@@ -0,0 +1,30 @@
+import {resolve} from 'path';
+
+function resolveRequire(path) {
+  if (path.startsWith('.')) {
+    return resolve(path);
+  }
+  return path;
+}
+
+export function requires(paths, req = require) {
+  if (paths) {
+    if (typeof paths === 'string') {
+      req(resolveRequire(paths));
+    } else {
+      paths.forEach((path) => {
+        req(resolveRequire(path));
+      });
+    }
+  }
+}
+
+export function entry(entry, req = require) {
+  if (typeof entry === 'object') {
+    if (entry.export) {
+      return req(resolveRequire(entry.path))[entry.export];
+    }
+    return req(resolveRequire(entry.path));
+  }
+  return req(resolveRequire(entry));
+}

test/helpers/common.js

@@ -1,2 +1,4 @@
 import chai from 'chai';
+import sinonChai from 'sinon-chai';
+chai.use(sinonChai);
 chai.should();

test/scenarios/basic/index.js

@@ -0,0 +1,2 @@
+export default (documents) => {
+};

test/src/schema.js

@@ -1,10 +1,18 @@
 import {Schema} from '../../src';
 
-const CONFIG = {};
+const CONFIG = {
+  entry: {
+    path: './test/scenarios/basic',
+    export: 'default',
+  },
+  require: [
+    '@babel/register',
+  ],
+};
 
 describe('Schema', () => {
   it('should pass', () => {
     const schema = new Schema(CONFIG);
-    schema.generate().should.eql(CONFIG);
+    schema.generate().should.eql({});
   });
 });

test/src/utils.js

@@ -0,0 +1,106 @@
+import _ from 'lodash';
+import sinon from 'sinon';
+import {resolve} from 'path';
+
+import {entry, requires} from '../../src/utils';
+
+const RELATIVE_PATH = './name';
+const NODE_MODULES_PATH = 'name';
+const EXPORT_NAME = 'export name';
+const EXPORT = 'export';
+const ENTRY = {
+  [EXPORT_NAME]: EXPORT,
+};
+
+describe('utils', () => {
+  describe('entry', () => {
+    const variations = {
+      'with a string': {
+        'should support a relative path': {
+          entry: RELATIVE_PATH,
+          ret: ENTRY,
+          req: resolve(RELATIVE_PATH),
+        },
+        'should support a node_modules path': {
+          entry: NODE_MODULES_PATH,
+          ret: ENTRY,
+          req: NODE_MODULES_PATH,
+        },
+      },
+      'with an object': {
+        'should support a relative path': {
+          entry: {path: RELATIVE_PATH},
+          ret: ENTRY,
+          req: resolve(RELATIVE_PATH),
+        },
+        'should support a node_modules path': {
+          entry: {path: NODE_MODULES_PATH},
+          ret: ENTRY,
+          req: NODE_MODULES_PATH,
+        },
+      },
+      'with an object and export': {
+        'should support a relative path': {
+          entry: {path: RELATIVE_PATH, export: EXPORT_NAME},
+          ret: EXPORT,
+          req: resolve(RELATIVE_PATH),
+        },
+        'should support a node_modules path': {
+          entry: {path: NODE_MODULES_PATH, export: EXPORT_NAME},
+          ret: EXPORT,
+          req: NODE_MODULES_PATH,
+        },
+      },
+    };
+
+    _.forEach(variations, (variation, name) => {
+      describe(name, () => {
+        _.forEach(variation, (test, name) => {
+          it(name, () => {
+            const req = sinon.spy(() => ENTRY);
+            const ret = entry(test.entry, req);
+            req.should.have.been.calledOnce;
+            req.should.have.been.calledWith(test.req);
+            ret.should.eql(test.ret);
+          });
+        });
+      });
+    });
+  });
+
+  describe('requires', () => {
+    describe('when undefined', () => {
+      it('should not require anything', () => {
+        const req = sinon.spy();
+        requires(undefined, req);
+        req.should.not.have.been.called;
+      });
+    });
+
+    describe('when a string', () => {
+      it('should support a relative path', () => {
+        const req = sinon.spy();
+        requires(RELATIVE_PATH, req);
+        req.should.have.been.calledOnce;
+        req.should.have.been.calledWith(resolve(RELATIVE_PATH));
+      });
+
+      it('should support a node_modules path', () => {
+        const req = sinon.spy();
+        requires(NODE_MODULES_PATH, req);
+        req.should.have.been.calledOnce;
+        req.should.have.been.calledWith(NODE_MODULES_PATH);
+      });
+    });
+
+    describe('when an array', () => {
+      it('should require all', () => {
+        const req = sinon.spy();
+        requires([RELATIVE_PATH, NODE_MODULES_PATH], req);
+        req.should.have.been.calledTwice;
+        req.should.have.been.calledWith(resolve(RELATIVE_PATH));
+        req.should.have.been.calledWith(NODE_MODULES_PATH);
+      });
+    });
+  });
+});