specmatic 0.70.8 → 0.72.1

package/README.md

@@ -82,6 +82,9 @@ View test results in any framework so that it shows up in IDE specific test resu
 `printJarVersion()` <br />
 method to print the version of specmatic.jar
 
+`enableApiCoverage(expressAppRef) ` <br />
+enable api coverage for express apps to know which apis and http verbs are covered in contract tests and which not
+
 ### Kafka APIs
 
 `startKafkaStub(port?: number, args?: (string | number)[]): Promise<KafkaStub>` <br />

package/dist/common/runner.js

@@ -25,7 +25,11 @@ var callKafka = (args, done, onOutput) => {
 exports.callKafka = callKafka;
 function callJar(jarPath, args, done, onOutput) {
   var _javaProcess$stdout, _javaProcess$stderr;
-  var javaProcess = (0, _execSh.default)("java -jar ".concat(jarPath, " ").concat(args), {
+  var java = 'java';
+  if (process.env['endpointsAPI']) {
+    java = "".concat(java, " -DendpointsAPI=\"").concat(process.env['endpointsAPI'], "\"");
+  }
+  var javaProcess = (0, _execSh.default)("".concat(java, " -jar ").concat(jarPath, " ").concat(args), {
     stdio: 'pipe',
     stderr: 'pipe'
   }, done);

package/dist/core/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.test = exports.stopStub = exports.startStub = exports.showTestResults = exports.setExpectations = exports.printJarVersion = exports.Stub = void 0;
+exports.test = exports.stopStub = exports.startStub = exports.showTestResults = exports.setExpectations = exports.printJarVersion = exports.enableApiCoverage = exports.Stub = void 0;
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 var _path = _interopRequireDefault(require("path"));
 var _fastXmlParser = require("fast-xml-parser");
@@ -11,12 +11,14 @@ var _fs = _interopRequireDefault(require("fs"));
 var _logger = _interopRequireDefault(require("../common/logger"));
 var _runner = require("../common/runner");
 var _promise = _interopRequireDefault(require("terminate/promise"));
+var _expressListEndpoints = _interopRequireDefault(require("express-list-endpoints"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var END_POINTS_API_ROUTE = '_specmatic/endpoints';
 class Stub {
   constructor(host, port, url, process) {
     _defineProperty(this, "host", void 0);
@@ -83,6 +85,10 @@ var stopStub = /*#__PURE__*/function () {
 }();
 exports.stopStub = stopStub;
 var test = (host, port, contractPath, args) => {
+  if (process.env['endpointsAPI']) {
+    var apiEndPointUrl = host && port ? "http://".concat(host, ":").concat(port, "/").concat(END_POINTS_API_ROUTE) : "http://localhost:8080/".concat(END_POINTS_API_ROUTE);
+    process.env['endpointsAPI'] = apiEndPointUrl;
+  }
   var specsPath = _path.default.resolve(contractPath + '');
   var cmd = "test";
   if (contractPath) cmd += " ".concat(specsPath);
@@ -164,6 +170,21 @@ var printJarVersion = () => {
   });
 };
 exports.printJarVersion = printJarVersion;
+var listEndPoints = expressApp => {
+  var details = (0, _expressListEndpoints.default)(expressApp);
+  var endPoints = {};
+  details.map(apiDetail => {
+    endPoints[apiDetail.path] = apiDetail.methods;
+  });
+  delete endPoints["/".concat(END_POINTS_API_ROUTE)];
+  return endPoints;
+};
+var enableApiCoverage = expressApp => {
+  process.env['endpointsAPI'] = END_POINTS_API_ROUTE;
+  addEndPointsRoute(expressApp);
+  _logger.default.info("Endpoints API registered at ".concat(END_POINTS_API_ROUTE));
+};
+exports.enableApiCoverage = enableApiCoverage;
 var parseJunitXML = () => {
   var reportPath = _path.default.resolve('dist/test-report/TEST-junit-jupiter.xml');
   var data = _fs.default.readFileSync(reportPath);
@@ -171,4 +192,31 @@ var parseJunitXML = () => {
   var resultXml = parser.parse(data);
   resultXml.testsuite.testcase = Array.isArray(resultXml.testsuite.testcase) ? resultXml.testsuite.testcase : [resultXml.testsuite.testcase];
   return resultXml.testsuite.testcase;
+};
+var addEndPointsRoute = expressApp => {
+  expressApp.get("/".concat(END_POINTS_API_ROUTE), (_req, res) => {
+    var endPoints = listEndPoints(expressApp);
+    var springActuatorPayload = {
+      contexts: {
+        application: {
+          mappings: {
+            dispatcherServlets: {
+              dispatcherServlet: []
+            }
+          }
+        }
+      }
+    };
+    Object.keys(endPoints).sort().map(path => {
+      springActuatorPayload.contexts.application.mappings.dispatcherServlets.dispatcherServlet.push({
+        details: {
+          requestMappingConditions: {
+            methods: endPoints[path].sort(),
+            patterns: [path]
+          }
+        }
+      });
+    });
+    res.send(springActuatorPayload);
+  });
 };

package/dist/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "enableApiCoverage", {
+  enumerable: true,
+  get: function get() {
+    return _core.enableApiCoverage;
+  }
+});
 Object.defineProperty(exports, "printJarVersion", {
   enumerable: true,
   get: function get() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmatic",
-  "version": "0.70.8",
+  "version": "0.72.1",
   "description": "Node wrapper for Specmatic",
   "main": "dist/index.js",
   "scripts": {
@@ -35,25 +35,31 @@
     "logLevel": "trace"
   },
   "dependencies": {
-    "@babel/cli": "^7.21.5",
-    "@babel/core": "^7.21.8",
-    "@babel/preset-env": "^7.21.5",
-    "@babel/preset-typescript": "^7.21.5",
-    "@types/node": "^20.2.3",
+    "@babel/cli": "^7.22.6",
+    "@babel/core": "^7.22.6",
+    "@babel/preset-env": "^7.22.6",
+    "@babel/preset-typescript": "^7.22.5",
+    "@types/node": "^20.3.3",
     "@types/node-fetch": "^2.6.4",
     "@types/yargs": "^17.0.24",
     "exec-sh": "^0.4.0",
-    "fast-xml-parser": "^4.2.2",
+    "express-list-endpoints": "^6.0.0",
+    "fast-xml-parser": "^4.2.5",
     "node-fetch": "^2.6.11",
     "rimraf": "^5.0.1",
     "terminate": "^2.6.1",
-    "winston": "^3.8.2",
+    "winston": "^3.9.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/express-list-endpoints": "^6.0.0",
     "@types/jest": "^29.5.2",
-    "jest": "^29.5.0",
+    "@types/supertest": "^2.0.12",
+    "express": "^4.18.2",
+    "jest": "^29.6.0",
     "jest-extended": "^4.0.0",
-    "jest-mock-extended": "^3.0.4"
+    "jest-mock-extended": "^3.0.4",
+    "supertest": "^6.3.3"
   }
 }

package/src/common/runner.ts

@@ -19,7 +19,11 @@ const callKafka = (args: string, done: (error: any) => void, onOutput: (message:
 };
 
 function callJar(jarPath: string, args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void) {
-    const javaProcess = execSh(`java -jar ${jarPath} ${args}`, { stdio: 'pipe', stderr: 'pipe' }, done);
+    let java = 'java';
+    if (process.env['endpointsAPI']) {
+        java = `${java} -DendpointsAPI="${process.env['endpointsAPI']}"`;
+    }
+    const javaProcess = execSh(`${java} -jar ${jarPath} ${args}`, { stdio: 'pipe', stderr: 'pipe' }, done);
     javaProcess.stdout?.on('data', function (data: String) {
         onOutput(`${data}`, false);
     });

package/src/core/__tests__/list.end.points.ts

@@ -0,0 +1,83 @@
+import * as specmatic from '../..';
+import express from 'express';
+import request from 'supertest';
+
+test('adds an environment variable indicating api endpoits route is configured', async () => {
+    var app = express();
+    app.get('/', () => {});
+
+    specmatic.enableApiCoverage(app);
+
+    expect(process.env.endpointsAPI).toBe('_specmatic/endpoints');
+});
+
+test('gives list of end points for a single route defined on express app', async () => {
+    var app = express();
+    app.get('/', () => {});
+
+    specmatic.enableApiCoverage(app);
+
+    const res = await request(app).get('/_specmatic/endpoints').accept('application/json').expect(200);
+    const response = generateResponseObject({ '/': ['GET'] });
+    expect(res.body).toStrictEqual(response);
+});
+
+test('gives list of end points for multiple routes defined on express app', async () => {
+    var app = express();
+    app.get('/', () => {});
+    app.post('/', () => {});
+    app.get('/ping', () => {});
+
+    specmatic.enableApiCoverage(app);
+
+    const res = await request(app).get('/_specmatic/endpoints').accept('application/json').expect(200);
+    const response = generateResponseObject({ '/': ['GET', 'POST'], '/ping': ['GET'] });
+    expect(res.body).toStrictEqual(response);
+});
+
+test('gives list of end points for a multiple routes defined on multiple routers', async () => {
+    var app = express();
+    const userRouter = express.Router();
+    userRouter.get('/', function (req, res) {});
+    userRouter.post('/', function (req, res) {});
+    userRouter.delete('/', function (req, res) {});
+    userRouter.put('/', function (req, res) {});
+
+    const productRouter = express.Router();
+    productRouter.get('/', function (req, res) {});
+    productRouter.post('/', function (req, res) {});
+
+    app.use('/user', userRouter);
+    app.use('/product', productRouter);
+
+    specmatic.enableApiCoverage(app);
+
+    const res = await request(app).get('/_specmatic/endpoints').accept('application/json').expect(200);
+    const response = generateResponseObject({ '/product': ['GET', 'POST'], '/user': ['DELETE', 'GET', 'POST', 'PUT'] });
+    expect(res.body).toStrictEqual(response);
+});
+
+function generateResponseObject(endPoints: { [key: string]: string[] }) {
+    const structure = {
+        contexts: {
+            application: {
+                mappings: {
+                    dispatcherServlets: {
+                        dispatcherServlet: [],
+                    },
+                },
+            },
+        },
+    };
+    Object.keys(endPoints).map(key => {
+        structure.contexts.application.mappings.dispatcherServlets.dispatcherServlet.push({
+            details: {
+                requestMappingConditions: {
+                    methods: endPoints[key],
+                    patterns: [key],
+                },
+            },
+        } as never);
+    });
+    return structure;
+}

package/src/core/__tests__/test.ts

@@ -163,6 +163,34 @@ test('invocation makes sure previous junit report if any is deleted', async func
     expect(spy).toHaveBeenCalledWith(path.resolve('dist/test-report'), { force: true, recursive: true });
 });
 
+test('passes an property indicating api endpoint based on host and port supplied when api coverage is enabled', async () => {
+    process.env['endpointsAPI'] = '/_specmatic/endpoints';
+    execSh.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        execSh.mock.calls[0][2]();
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT)).resolves.toBeTruthy();
+
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -DendpointsAPI=\"http://${HOST}:${PORT}/_specmatic/endpoints\" -jar ${path.resolve(SPECMATIC_JAR_PATH)} test --junitReportDir=dist/test-report --host=localhost --port=8000`);
+});
+
+test('passes an property indicating api endpoint based on defaults if host and port not provided when api coverage is enabled', async () => {
+    process.env['endpointsAPI'] = '/_specmatic/endpoints';
+    execSh.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        execSh.mock.calls[0][2]();
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT)).resolves.toBeTruthy();
+
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -DendpointsAPI=\"http://${HOST}:${PORT}/_specmatic/endpoints\" -jar ${path.resolve(SPECMATIC_JAR_PATH)} test --junitReportDir=dist/test-report --host=localhost --port=8000`);
+});
+
 function copyReportFile() {
     copyReportFileWithName('sample-junit-result-multiple.xml');
 }

package/src/core/index.ts

@@ -6,6 +6,9 @@ import fs from 'fs';
 import logger from '../common/logger';
 import { callSpecmatic } from '../common/runner';
 import terminate from 'terminate/promise';
+import listExpressEndpoints from 'express-list-endpoints';
+
+const END_POINTS_API_ROUTE = '_specmatic/endpoints';
 
 export class Stub {
     host: string;
@@ -74,6 +77,11 @@ const stopStub = async (stub: Stub) => {
 };
 
 const test = (host?: string, port?: number, contractPath?: string, args?: (string | number)[]): Promise<{ [k: string]: number } | undefined> => {
+    if (process.env['endpointsAPI']) {
+        const apiEndPointUrl = host && port ? `http://${host}:${port}/${END_POINTS_API_ROUTE}` : `http://localhost:8080/${END_POINTS_API_ROUTE}`;
+        process.env['endpointsAPI'] = apiEndPointUrl;
+    }
+
     const specsPath = path.resolve(contractPath + '');
 
     var cmd = `test`;
@@ -169,6 +177,22 @@ const printJarVersion = () => {
     );
 };
 
+const listEndPoints = (expressApp: any): { [key: string]: string[] } => {
+    const details = listExpressEndpoints(expressApp);
+    let endPoints: { [key: string]: string[] } = {};
+    details.map(apiDetail => {
+        endPoints[apiDetail.path] = apiDetail.methods;
+    });
+    delete endPoints[`/${END_POINTS_API_ROUTE}`];
+    return endPoints;
+};
+
+const enableApiCoverage = (expressApp: any) => {
+    process.env['endpointsAPI'] = END_POINTS_API_ROUTE;
+    addEndPointsRoute(expressApp);
+    logger.info(`Endpoints API registered at ${END_POINTS_API_ROUTE}`);
+};
+
 const parseJunitXML = () => {
     const reportPath = path.resolve('dist/test-report/TEST-junit-jupiter.xml');
     var data = fs.readFileSync(reportPath);
@@ -178,4 +202,32 @@ const parseJunitXML = () => {
     return resultXml.testsuite.testcase;
 };
 
-export { startStub, stopStub, test, setExpectations, printJarVersion, showTestResults };
+const addEndPointsRoute = (expressApp: any) => {
+    expressApp.get(`/${END_POINTS_API_ROUTE}`, (_req: any, res: any) => {
+        let endPoints = listEndPoints(expressApp);
+        let springActuatorPayload = {
+            contexts: {
+                application: {
+                    mappings: {
+                        dispatcherServlets: {
+                            dispatcherServlet: [],
+                        },
+                    },
+                },
+            },
+        };
+        Object.keys(endPoints).sort().map(path => {
+            springActuatorPayload.contexts.application.mappings.dispatcherServlets.dispatcherServlet.push({
+                details: {
+                    requestMappingConditions: {
+                        methods: endPoints[path].sort(),
+                        patterns: [path],
+                    },
+                },
+            } as never);
+        });
+        res.send(springActuatorPayload);
+    });
+}
+
+export { startStub, stopStub, test, setExpectations, printJarVersion, showTestResults, enableApiCoverage };

package/src/index.ts

@@ -1,2 +1,2 @@
-export { startStub, stopStub, test, setExpectations, printJarVersion, showTestResults } from './core';
+export { startStub, stopStub, test, setExpectations, printJarVersion, showTestResults, enableApiCoverage } from './core';
 export { startKafkaStub, stopKafkaStub, verifyKafkaStubMessage, verifyKafkaStub, setKafkaStubExpectations } from './kafka';