feat: test file for controller

version

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liftr/cli",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "The Liftr CLI provides scaffolding for the Liftr framework",
   "author": "Faris Tangastani",
   "repository": "https://github.com/farisT/liftr",

src/create/createController.ts

@@ -1,25 +1,26 @@
 import fs from 'fs-extra';
 import chalk from 'chalk';
 import { checkExistence } from '../helpers';
+import { createTestController } from './testing/createTestController';
 
-export const createController = (ControllerName: string) => {
+export const createController = async (ControllerName: string) => {
     const fileContent: string = `
 import { Request, Response } from 'express';
 
 export let ${ControllerName}Controller = (req: Request, res: Response) => {
         // Methods to respond to the request at the route e.g:
-        res.send('${ControllerName} route');
+        res.send('${ControllerName} controller');
     };
 `;
     const filepath: string = process.cwd() + `/src/controllers/${ControllerName}.controller.ts`;
-    const check = checkExistence(`/src/controllers/${ControllerName}.controller.ts`)
-    if(!check) {
-        fs.writeFile(filepath, fileContent, (err) => {
+    const check = checkExistence(`/src/controllers/${ControllerName}.controller.ts`);
+    if (!check) {
+        await fs.writeFile(filepath, fileContent, (err) => {
             if (err) throw err;
         });
-    }
-    else {
-        console.error(chalk.red(`Controller named ${ControllerName} already exists!`)); 
+        await createTestController(ControllerName);
+    } else {
+        console.error(chalk.red(`Controller named ${ControllerName} already exists!`));
         process.exit(1);
     }
 };

src/create/createExampleApi.ts

@@ -5,6 +5,7 @@ export const createExampleApi = async (setupName: string) => {
     const fileContent = null;
     const RoutePath: string = process.cwd() + `/${setupName}/src/routes/liftr.route.ts`;
     const ControllerPath: string = process.cwd() + `/${setupName}/src/controllers/liftr.controller.ts`;
+    const ControllerSpecPath: string = process.cwd() + `/${setupName}/src/controllers/liftr.controller.spec.ts`;
     const MiddleWarePath: string = process.cwd() + `/${setupName}/src/middleware/liftr.middleware.ts`;
     const RoutingPath: string = process.cwd() +  `/${setupName}/src/routes/LiftrRoutingModule.ts`;
 
@@ -13,6 +14,7 @@ export const createExampleApi = async (setupName: string) => {
         ControllerPath,
         RoutingPath,
         MiddleWarePath,
+        ControllerSpecPath,
     ];
     await creationArray.forEach(async (createPath) => {
         await fs.writeFile(createPath, fileContent, (err) => {
@@ -27,6 +29,9 @@ export const createExampleApi = async (setupName: string) => {
         if (createPath.includes('liftr.controller.ts')) {
             await fs.copySync(path.resolve(__dirname, '../templates/controller.ts'), createPath);
         }
+        if (createPath.includes('liftr.controller.spec.ts')) {
+            await fs.copySync(path.resolve(__dirname, '../templates/controller.spec.ts'), createPath);
+        }
         if (createPath.includes('liftr.middleware.ts')) {
             await fs.copySync(path.resolve(__dirname, '../templates/middleware.ts'), createPath);
         }

src/create/createMiddleware.ts

@@ -11,14 +11,13 @@ export const ${MiddlewareName}Middleware = (req: Request, res: Response, next: N
 };
 `;
     const filepath = process.cwd() + `/src/middleware/${MiddlewareName}.middleware.ts`;
-    const check = checkExistence(`/src/middleware/${MiddlewareName}.middleware.ts`)
-    if(!check) {
+    const check = checkExistence(`/src/middleware/${MiddlewareName}.middleware.ts`);
+    if (!check) {
         fs.writeFile(filepath, fileContent, (err) => {
                 if (err) throw err;
         });
-    }   
-    else {
-        console.error(chalk.red(`Middleware named ${MiddlewareName} already exists!`)); 
+    } else {
+        console.error(chalk.red(`Middleware named ${MiddlewareName} already exists!`));
         process.exit(1);
     }
 };

src/create/createRoute.ts

@@ -12,13 +12,12 @@ export const ${RouteName}Route: Router = Router()
     .get('/', ${RouteName}Controller);
 `;
     const filepath = process.cwd() + `/src/routes/${RouteName}.route.ts`;
-    const check = checkExistence(`/src/routes/${RouteName}.route.ts`)
-    if(!check) {
+    const check = checkExistence(`/src/routes/${RouteName}.route.ts`);
+    if (!check) {
         fs.writeFileSync(filepath, fileContent);
         createController(RouteName);
-    }
-    else {
-        console.error(chalk.red(`Route named ${RouteName} already exists!`)); 
+    } else {
+        console.error(chalk.red(`Route named ${RouteName} already exists!`));
         process.exit(1);
     }
 };

src/create/createTesting.ts

@@ -5,20 +5,25 @@ export const createTesting = async (setupName: string) => {
     const fileContent = null;
     const mochaSetup: string = process.cwd() + `/${setupName}/test/mocha.opts`;
     const nycSetup: string = process.cwd() + `/${setupName}/.nycrc`;
+    const mochaRequire: string = process.cwd() + `/${setupName}/test/mocha.require.ts`;
 
     const testingFiles: string[] = [
         mochaSetup,
         nycSetup,
+        mochaRequire,
     ];
     await testingFiles.forEach(async (createPath) => {
         await fs.writeFile(createPath, fileContent, (err) => {
-            // if (err) throw err;
+            // if (err) console.error('Cant create files');
         });
         if (createPath.includes('mocha.opts')) {
             await fs.copySync(path.resolve(__dirname, '../templates/mocha.opts'), createPath);
         }
         if (createPath.includes('.nycrc')) {
             await fs.copySync(path.resolve(__dirname, '../templates/.nycrc'), createPath);
         }
+        if (createPath.includes('mocha.require.ts')) {
+            await fs.copySync(path.resolve(__dirname, '../templates/mocha.require.ts'), createPath);
+        }
     });
 };

src/create/testing/createTestController.ts

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+
+export const createTestController = (controllerName: string) => {
+    const filepath: string = process.cwd() + `/src/controllers/${controllerName}.controller.spec.ts`;
+    const fileContent = `import * as sinon from 'sinon';
+import { expect } from 'chai';
+import { Request, Response } from 'express';
+import { ${controllerName}Controller } from './${controllerName}.controller';
+
+describe('src/controllers/${controllerName}.controller.ts', () => {
+    let sandbox: sinon.SinonSandbox;
+    let req: any = {};
+    let responseStub: Partial<Response>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        responseStub = {
+            send: sandbox.stub(),
+        }
+    });
+
+    it('should send a message' , () => {
+        ${controllerName}Controller(req as Request, responseStub as Response);
+        expect(responseStub.send).to.be.calledWith('${controllerName} controller');
+        });
+});
+`;
+    fs.writeFile(filepath, fileContent, (err) => {
+        if (err) throw err;
+    });
+};

templates/controller.spec.ts

@@ -0,0 +1,22 @@
+import * as sinon from 'sinon';
+import { expect } from 'chai';
+import { Request, Response } from 'express';
+import { liftrController } from './liftr.controller';
+
+describe('src/controllers/liftr.controller.ts', () => {
+    let sandbox: sinon.SinonSandbox;
+    let req: any = {};
+    let responseStub: Partial<Response>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        responseStub = {
+            send: sandbox.stub(),
+        }
+    });
+
+    it('should send a message' , () => {
+        liftrController(req as Request, responseStub as Response);
+        expect(responseStub.send).to.be.calledWith('Lift off!');
+    });
+});

templates/controller.ts

@@ -1,5 +1,5 @@
 import { Request, Response } from 'express';
 
-export let LiftrController = (req: Request, res: Response) => {
+export let liftrController = (req: Request, res: Response) => {
     res.send('Lift off!');
 };

templates/middleware.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from 'express';
 
-export const LiftrMiddleware = (req: Request, res: Response, next: NextFunction) => {
+export const liftrMiddleware = (req: Request, res: Response, next: NextFunction) => {
     return next();
 };

templates/mocha.opts

@@ -1,3 +1,4 @@
+-r ts-node/register test/mocha.require.ts
 -r tsconfig-paths/register
 -R spec
 --recursive

templates/mocha.require.ts

@@ -0,0 +1 @@
+require('chai').use(require('sinon-chai'));

templates/route.ts

@@ -1,5 +1,5 @@
 import { Router, Request, Response, NextFunction} from "express"
-import { LiftrController } from "@controllers/liftr.controller"
+import { liftrController } from "@controllers/liftr.controller"
 
-export const LiftrRoute: Router = Router()
-  .get('/', LiftrController);
+export const liftrRoute: Router = Router()
+  .get('/', liftrController);

templates/routes.ts

@@ -1,10 +1,10 @@
 import { AppRouter } from '@liftr/core'
-import { LiftrRoute } from '@routes/liftr.route'
+import { liftrRoute } from '@routes/liftr.route'
 
 
 export const routes: AppRouter[] = [
   {
-    handler: LiftrRoute,
+    handler: liftrRoute,
     middleware: [],
     path: '/',
   },