Merge pull request #2 from temando/tests

Tests

Author: nfour

package.json

@@ -15,6 +15,10 @@
     "test:coverage": "jest --coverage",
     "lint": "tslint 'src/**/*.ts'",
     "release": "cd build && npm publish",
+    "test:project": "cd test/project && yarn sls openapi generate",
+    "test:prepare": "scripts/prepareTests.bash",
+    "build:link": "yarn build && cd build && yarn link",
+    "build:watch": "yarn build && tsc --watch",
     "build": "scripts/build.bash"
   },
   "devDependencies": {

scripts/prepareTests.bash

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+
+yarn build:link \
+  && cd test/project \
+  && yarn \
+  && yarn link serverless-openapi-documentation

src/DocumentGenerator.ts renamed to src/DefinitionGenerator.ts

@@ -1,77 +1,76 @@
 import { dereference } from '@jdw/jst';
-import * as c from 'chalk';
-import * as openApiValidator from 'swagger2openapi/validate.js';
+import * as openApiValidator from 'swagger2openapi/validate';
 
 import * as uuid from 'uuid';
-import { IParameterConfig, IServerlessFunctionConfig, IServiceDescription } from './types';
+import { IDefinition, IDefinitionConfig, IParameterConfig, IServerlessFunctionConfig } from './types';
 import { clone, merge } from './utils';
 
-export class DocumentGenerator {
+export class DefinitionGenerator {
   // The OpenAPI version we currently validate against
-  private openapiVersion = '3.0.0-RC1';
+  public version = '3.0.0-RC1';
 
   // Base configuration object
-  private config = {
-    openapi: this.openapiVersion,
-    description: '',
-    version: '0.0.0',
-    title: '',
-    paths: {},
-    components: {
-      schemas: {},
-    },
+  public definition = <IDefinition> {
+    openapi: this.version,
+    components: {},
   };
 
-  private serviceDescriptor: IServiceDescription;
+  public config: IDefinitionConfig;
 
   /**
    * Constructor
    * @param serviceDescriptor IServiceDescription
    */
-  constructor (serviceDescriptor: IServiceDescription) {
-    this.serviceDescriptor = clone(serviceDescriptor);
-
-    merge(this.config, {
-      openapi: this.openapiVersion,
-      servers: [],
-      info: {
-        title: serviceDescriptor.summary || '',
-        description: serviceDescriptor.description || '',
-        version: serviceDescriptor.version || uuid.v4(),
-      },
+  constructor (config: IDefinitionConfig) {
+    this.config = clone(config);
+  }
+
+  public parse () {
+    const {
+      title = '',
+      description = '',
+      version = uuid.v4(),
+      models,
+    } = this.config;
+
+    merge(this.definition, {
+      openapi: this.version,
+      info: { title, description, version },
       paths: {},
       components: {
         schemas: {},
         securitySchemes: {},
       },
     });
 
-    for (const model of serviceDescriptor.models) {
-      this.config.components.schemas[model.name] = this.cleanSchema(dereference(model.schema));
+    if (models) {
+      for (const model of models) {
+        this.definition.components.schemas[model.name] = this.cleanSchema(
+          dereference(model.schema),
+        );
+      }
     }
+
+    return this;
   }
 
-  public generate () {
-    const result: any = {};
-    process.stdout.write(`${ c.bold.yellow('[VALIDATION]') } Validating OpenAPI generated output\n`);
+  public validate (): { valid: boolean, context: string[], warnings: any[], error?: any[] } {
+    const payload: any = {};
+
     try {
-      openApiValidator.validateSync(this.config, result);
-      process.stdout.write(`${ c.bold.green('[VALIDATION]') } OpenAPI valid: ${c.bold.green('true')}\n\n`);
-      return this.config;
-    } catch (e) {
-      process.stdout.write(
-        `${c.bold.red('[VALIDATION]')} Failed to validate OpenAPI document: \n\n${c.yellow(e.message)}\n\n` +
-        `${c.bold.green('Path:')} ${result.context.pop()}\n`,
-        );
-      throw new Error('Failed to validate OpenAPI document');
+      openApiValidator.validateSync(this.definition, payload);
+    } catch (error) {
+      payload.error = JSON.parse(error.message.replace(/^Failed OpenAPI3 schema validation: /, ''));
     }
+
+    return payload;
   }
 
   /**
    * Add Paths to OpenAPI Configuration from Serverless function documentation
    * @param config Add
    */
-  public addPathsFromFunctionConfig (config: IServerlessFunctionConfig[]): void {
+  public readFunctions (config: IServerlessFunctionConfig[]): void {
     // loop through function configurations
     for (const funcConfig of config) {
       // loop through http events
@@ -93,7 +92,7 @@ export class DocumentGenerator {
             },
           };
           // merge path configuration into main configuration
-          merge(this.config.paths, pathConfig);
+          merge(this.definition.paths, pathConfig);
         }
       }
     }
@@ -170,7 +169,6 @@ export class DocumentGenerator {
             : parameter.style === 'form';
         }
 
-        // console.log(parameter);
         if (parameter.schema) {
           parameterConfig.schema = this.cleanSchema(parameter.schema);
         }
@@ -181,7 +179,6 @@ export class DocumentGenerator {
           parameterConfig.examples = parameter.examples;
         }
 
-        // Add parameter config to parameters array
         parameters.push(parameterConfig);
       }
     }
@@ -201,7 +198,7 @@ export class DocumentGenerator {
       // For each request model type (Sorted by "Content-Type")
       for (const requestModelType of Object.keys(documentationConfig.requestModels)) {
         // get schema reference information
-        const requestModel = this.serviceDescriptor.models.filter(
+        const requestModel = this.config.models.filter(
           (model) => model.name === documentationConfig.requestModels[requestModelType],
         ).pop();
 
@@ -278,7 +275,7 @@ export class DocumentGenerator {
   private getResponseContent (response) {
     const content = {};
     for (const responseKey of Object.keys(response)) {
-      const responseModel = this.serviceDescriptor.models.filter(
+      const responseModel = this.config.models.filter(
           (model) => model.name === response[responseKey],
         ).pop();
       if (responseModel) {
@@ -295,7 +292,7 @@ export class DocumentGenerator {
         merge(content, { [responseKey] : resModelConfig });
       }
     }
-    // console.log(content);
+
     return content;
   }
 

src/ServerlessOpenApiDocumentation.ts

@@ -1,8 +1,9 @@
 import * as c from 'chalk';
 import * as fs from 'fs';
 import * as YAML from 'js-yaml';
-import { DocumentGenerator } from './DocumentGenerator';
-import { IConfigType } from './types';
+import { inspect } from 'util';
+import { DefinitionGenerator } from './DefinitionGenerator';
+import { IDefinitionType, ILog } from './types';
 import { merge } from './utils';
 
 export class ServerlessOpenApiDocumentation {
@@ -62,12 +63,16 @@ export class ServerlessOpenApiDocumentation {
     };
   }
 
+  log: ILog = (...str: string[]) => {
+    process.stdout.write(str.join(' '));
+  }
+
   /**
    * Processes CLI input by reading the input from serverless
    * @returns config IConfigType
    */
-  private processCliInput (): IConfigType {
-    const config: IConfigType = {
+  private processCliInput (): IDefinitionType {
+    const config: IDefinitionType = {
       format: 'yaml',
       file: 'openapi.yml',
       indent: 2,
@@ -83,22 +88,25 @@ export class ServerlessOpenApiDocumentation {
     config.file = this.serverless.processedInput.options.output ||
       ((config.format === 'yaml') ? 'openapi.yml' : 'openapi.json');
 
-    process.stdout.write(
-      `${c.bold.green('[OPTIONS]')} ` +
-      `format: "${c.bold.red(config.format)}", ` +
-      `output file: "${c.bold.red(config.file)}", ` +
+    this.log(
+      `${c.bold.green('[OPTIONS]')}`,
+      `format: "${c.bold.red(config.format)}",`,
+      `output file: "${c.bold.red(config.file)}",`,
       `indentation: "${c.bold.red(String(config.indent))}"\n\n`,
-      );
+    );
+
     return config;
   }
 
   /**
    * Generates OpenAPI Documentation based on serverless configuration and functions
    */
   private generate () {
-    process.stdout.write(c.bold.underline('OpenAPI v3 Documentation Generator\n\n'));
+    this.log(c.bold.underline('OpenAPI v3 Documentation Generator\n\n'));
     // Instantiate DocumentGenerator
-    const dg = new DocumentGenerator(this.customVars.documentation);
+    const generator = new DefinitionGenerator(this.customVars.documentation);
+
+    generator.parse();
 
     // Map function configurations
     const funcConfigs = this.serverless.service.getAllFunctions().map((functionName) => {
@@ -107,28 +115,46 @@ export class ServerlessOpenApiDocumentation {
     });
 
     // Add Paths to OpenAPI Output from Function Configuration
-    dg.addPathsFromFunctionConfig(funcConfigs);
+    generator.readFunctions(funcConfigs);
 
     // Process CLI Input options
     const config = this.processCliInput();
 
-    // Generate the resulting OpenAPI Object
-    const outputObject = dg.generate();
+    this.log(`${ c.bold.yellow('[VALIDATION]') } Validating OpenAPI generated output\n`);
+
+    const validation = generator.validate();
+
+    if (validation.valid) {
+      this.log(`${ c.bold.green('[VALIDATION]') } OpenAPI valid: ${c.bold.green('true')}\n\n`);
+    } else {
+      this.log(`${c.bold.red('[VALIDATION]')} Failed to validate OpenAPI document: \n\n`);
+      this.log(`${c.bold.green('Path:')} ${JSON.stringify(validation.context, null, 2)}\n`);
+
+      for (const info of validation.error) {
+        this.log(c.grey('\n\n--------\n\n'));
+        this.log(' ', info.schemaPath, c.bold.yellow(info.message));
+        this.log(c.grey('\n\n--------\n\n'));
+        this.log(`${inspect(info, { colors: true, depth: 2 })}\n\n`);
+      }
+    }
+
+    const { definition } = generator;
 
     // Output the OpenAPI document to the correct format
-    let outputContent = '';
+
+    let output;
     switch (config.format.toLowerCase()) {
     case 'json':
-      outputContent = JSON.stringify(outputObject, null, config.indent);
+      output = JSON.stringify(definition, null, config.indent);
       break;
     case 'yaml':
     default:
-      outputContent = YAML.safeDump(outputObject, { indent: config.indent });
+      output = YAML.safeDump(definition, { indent: config.indent });
       break;
     }
 
-    // Write to disk
-    fs.writeFileSync(config.file, outputContent);
-    process.stdout.write(`${ c.bold.green('[SUCCESS]') } Output file to "${c.bold.red(config.file)}"\n`);
+    fs.writeFileSync(config.file, output);
+
+    this.log(`${ c.bold.green('[OUTPUT]') } To "${c.bold.red(config.file)}"\n`);
   }
 }

src/__tests__/DocumentGenerator.spec.ts renamed to src/__tests__/DefinitionGenerator.spec.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as Serverless from 'serverless';
-import { DocumentGenerator } from '../DocumentGenerator';
+import { DefinitionGenerator } from '../DefinitionGenerator';
 
 class ServerlessInterface extends Serverless {
   public service: any = {};
@@ -12,7 +12,7 @@ class ServerlessInterface extends Serverless {
 
 describe('OpenAPI Documentation Generator', () => {
   it('Generates OpenAPI document', async () => {
-    const servicePath = path.join(__dirname, './fixtures');
+    const servicePath = path.join(__dirname, '../../test/project');
     const serverlessYamlPath = path.join(servicePath, './serverless.yml');
     const sls: ServerlessInterface = new Serverless();
 
@@ -27,7 +27,7 @@ describe('OpenAPI Documentation Generator', () => {
     await sls.variables.populateService();
 
     if ('documentation' in sls.service.custom) {
-      const docGen = new DocumentGenerator(sls.service.custom.documentation);
+      const docGen = new DefinitionGenerator(sls.service.custom.documentation);
 
       expect(docGen).not.toBeNull();
     } else {