specmatic 0.65.2 → 0.67.0

package/src/lib/__tests__/index.ts

@@ -3,120 +3,207 @@ import fetch from 'node-fetch';
 import path from 'path';
 import { ChildProcess } from 'child_process';
 import { mock as jestMock } from 'jest-mock-extended';
-import { Readable } from "stream";
+import { Readable } from 'stream';
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
 
-import * as specmatic from '../';
-import { startStub, stopStub, printJarVersion, setExpectations } from '../';
+import * as specmatic from '../../';
 import { specmaticJarPathLocal } from '../../config';
-import mockStub from '../../../mockStub.json';
+import mockStub from '../../../test-resources/sample-mock-stub.json';
 
 jest.mock('exec-sh');
 jest.mock('node-fetch');
 
-const contractsPath = './contracts';
-const stubDataPath = './data';
-const host = 'localhost';
-const port = '8000';
+const STUB_PATH = 'test-resources/sample-mock-stub.json';
+const CONTRACT_YAML_FILE_PATH = './contracts';
+const STUB_DIR_PATH = './data';
+const HOST = 'localhost';
+const PORT = '8000';
+
 const javaProcessMock = jestMock<ChildProcess>();
 const readableMock = jestMock<Readable>();
 javaProcessMock.stdout = readableMock;
 javaProcessMock.stderr = readableMock;
 
 beforeEach(() => {
-  execSh.mockReset();
-  fetch.mockReset();
+    execSh.mockReset();
+    fetch.mockReset();
 });
 
 test('startStub method starts the specmatic stub server', async () => {
-  execSh.mockReturnValue(javaProcessMock);
+    execSh.mockReturnValue(javaProcessMock);
 
-  startStub(host, port, stubDataPath).then(javaProcess => {
-    expect(javaProcess).toBe(javaProcessMock);
-  })
+    specmatic.startStub(HOST, PORT, STUB_DIR_PATH).then(javaProcess => {
+        expect(javaProcess).toBe(javaProcessMock);
+    });
 
-  readableMock.on.mock.calls[0][1]("Stub server is running");
+    readableMock.on.mock.calls[0][1]('Stub server is running');
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-  .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --data=${path.resolve(stubDataPath)} --host=${host} --port=${port}`);
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(
+        `java -jar ${path.resolve(specmaticJarPathLocal)} stub --data=${path.resolve(STUB_DIR_PATH)} --host=${HOST} --port=${PORT}`
+    );
 });
 
 test('startStub method stubDir is optional', async () => {
-  execSh.mockReturnValue(javaProcessMock);
+    execSh.mockReturnValue(javaProcessMock);
 
-  startStub(host, port).then(javaProcess => {
-    expect(javaProcess).toBe(javaProcessMock);
-  })
+    specmatic.startStub(HOST, PORT).then(javaProcess => {
+        expect(javaProcess).toBe(javaProcessMock);
+    });
 
-  readableMock.on.mock.calls[0][1]("Stub server is running");
+    readableMock.on.mock.calls[0][1]('Stub server is running');
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --host=${host} --port=${port}`);
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --host=${HOST} --port=${PORT}`);
 });
 
 test('startStub method host and port are optional', async () => {
-  execSh.mockReturnValue(javaProcessMock);
+    execSh.mockReturnValue(javaProcessMock);
 
-  startStub().then(javaProcess => {
-    expect(javaProcess).toBe(javaProcessMock);
-  })
+    specmatic.startStub().then(javaProcess => {
+        expect(javaProcess).toBe(javaProcessMock);
+    });
 
-  readableMock.on.mock.calls[0][1]("Stub server is running");
+    readableMock.on.mock.calls[0][1]('Stub server is running');
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub`);
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub`);
 });
 
 test('stopStub method stops any running stub server', () => {
-  stopStub(javaProcessMock);
+    specmatic.stopStub(javaProcessMock);
 
-  expect(readableMock.removeAllListeners).toHaveBeenCalledTimes(2);
-  expect(javaProcessMock.removeAllListeners).toHaveBeenCalledTimes(1);
-  expect(javaProcessMock.kill).toHaveBeenCalledTimes(1);
+    expect(readableMock.removeAllListeners).toHaveBeenCalledTimes(2);
+    expect(javaProcessMock.removeAllListeners).toHaveBeenCalledTimes(1);
+    expect(javaProcessMock.kill).toHaveBeenCalledTimes(1);
 });
 
 test('test runs the contract tests', function (done) {
-    specmatic.test(contractsPath, host, port).then(result => {
-      expect(result).toBeTruthy();
-      done();
+    specmatic.test(HOST, PORT, CONTRACT_YAML_FILE_PATH).then(result => {
+        expect(result).toBeTruthy();
+        done();
+    });
+    copyReportFile();
+    execSh.mock.calls[0][2](); //Execute the callback
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(
+        `java -jar ${path.resolve(specmaticJarPathLocal)} test ${path.resolve(
+            CONTRACT_YAML_FILE_PATH
+        )} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`
+    );
+});
+
+test('test runs the contract tests with host and port optional', function (done) {
+    specmatic.test().then(result => {
+        expect(result).toBeTruthy();
+        done();
+    });
+    copyReportFile();
+    execSh.mock.calls[0][2](); //Execute the callback
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report`);
+});
+
+test('test runs the contract tests with contracts path optional', function (done) {
+    specmatic.test(HOST, PORT).then(result => {
+        expect(result).toBeTruthy();
+        done();
     });
+    copyReportFile();
     execSh.mock.calls[0][2](); //Execute the callback
     expect(execSh).toHaveBeenCalledTimes(1);
-    expect(execSh.mock.calls[0][0])
-      .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} test ${path.resolve(contractsPath)} --host=${host} --port=${port}`);
-  });
+    expect(execSh.mock.calls[0][0]).toBe(
+        `java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`
+    );
+});
+
+test('test runs the contract tests and get summary', function (done) {
+    specmatic.test().then(result => {
+        expect(result).not.toBeUndefined();
+        expect(result!.count).toBe(5);
+        expect(result!.success).toBe(3);
+        expect(result!.failure).toBe(2);
+        done();
+    });
+    copyReportFile();
+    execSh.mock.calls[0][2](); //Execute the callback
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report`);
+});
+
+test('test runs the contract tests and get summary when there is just one test', function (done) {
+    specmatic.test().then(result => {
+        expect(result).not.toBeUndefined();
+        expect(result!.count).toBe(1);
+        expect(result!.success).toBe(1);
+        expect(result!.failure).toBe(0);
+        done();
+    });
+    copyReportFileWithName('sample-junit-result-single.xml');
+    execSh.mock.calls[0][2](); //Execute the callback
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report`);
+});
+
+test('test invocation makes sure previous junit report if any is deleted', function (done) {
+    copyReportFileWithName('sample-junit-result-single.xml');
+    specmatic.test(HOST, PORT).then(result => {
+        expect(result).toBeTruthy();
+        done();
+    });
+    expect(existsSync(path.resolve('dist/test-report'))).toBeFalsy();
+    copyReportFileWithName('sample-junit-result-single.xml');
+    execSh.mock.calls[0][2](); //Execute the callback
+});
 
 test('printJarVersion', () => {
-  printJarVersion();
+    specmatic.printJarVersion();
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} --version`);
+    expect(execSh).toHaveBeenCalledTimes(1);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} --version`);
 });
 
-test('setExpectations with default baseUrl', () => {
-  fetch.mockReturnValue(Promise.resolve("{}"));
-  setExpectations(path.resolve('./mockStub.json'));
+test('setExpectations with default baseUrl', done => {
+    fetch.mockReturnValue(Promise.resolve('{}'));
+    specmatic.setExpectations(path.resolve(STUB_PATH)).then(result => {
+        expect(result).toBeTruthy();
+        done();
+    });
 
-  expect(fetch).toHaveBeenCalledTimes(1);
-  expect(fetch.mock.calls[0][0]).toBe('http://localhost:9000/_specmatic/expectations');
-  expect(fetch.mock.calls[0][1]).toMatchObject({
-    method: 'POST',
-    body: JSON.stringify(mockStub)
-  });
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch.mock.calls[0][0]).toBe('http://localhost:9000/_specmatic/expectations');
+    expect(fetch.mock.calls[0][1]).toMatchObject({
+        method: 'POST',
+        body: JSON.stringify(mockStub),
+    });
 });
 
-test('setExpectations with a different baseUrl for the stub server', () => {
-  fetch.mockReturnValue(Promise.resolve("{}"));
-  const stubServerBaseUrl = 'http://localhost:8000/'
-  setExpectations(path.resolve('./mockStub.json'), stubServerBaseUrl);
-
-  expect(fetch).toHaveBeenCalledTimes(1);
-  expect(fetch.mock.calls[0][0]).toBe(`${stubServerBaseUrl}_specmatic/expectations`);
-  expect(fetch.mock.calls[0][1]).toMatchObject({
-    method: 'POST',
-    body: JSON.stringify(mockStub)
-  });
+test('setExpectations with a different baseUrl for the stub server', done => {
+    fetch.mockReturnValue(Promise.resolve('{}'));
+    const stubServerBaseUrl = 'http://localhost:8000/';
+    specmatic.setExpectations(path.resolve(STUB_PATH), stubServerBaseUrl).then(result => {
+        expect(result).toBeTruthy();
+        done();
+    });
+
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch.mock.calls[0][0]).toBe(`${stubServerBaseUrl}_specmatic/expectations`);
+    expect(fetch.mock.calls[0][1]).toMatchObject({
+        method: 'POST',
+        body: JSON.stringify(mockStub),
+    });
 });
+
+function copyReportFile() {
+    copyReportFileWithName('sample-junit-result-multiple.xml');
+}
+
+function copyReportFileWithName(fileName: string) {
+    const destDir = path.resolve('dist/test-report');
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+    const srcPath = path.resolve('test-resources', fileName);
+    const destPath = path.resolve(destDir, 'TEST-junit-jupiter.xml');
+    copyFileSync(srcPath, destPath);
+}

package/src/lib/core.ts

@@ -0,0 +1,18 @@
+import execSh from 'exec-sh';
+import path from 'path';
+import { specmaticJarPathLocal } from '../config';
+
+const callSpecmaticCli = (args?: string[]) => {
+    const specmaticJarPath = path.resolve(specmaticJarPathLocal);
+    const cliArgs = (args || process.argv).slice(2).join(' ');
+
+    console.log('starting specmatic server', cliArgs);
+    execSh(`java -jar ${specmaticJarPath} ${cliArgs}`, {}, (err: any) => {
+        if (err) {
+            console.log('Exit code: ', err.code);
+            process.exit(err.code);
+        }
+    });
+};
+
+export default callSpecmaticCli;

package/src/lib/index.ts

@@ -3,17 +3,19 @@ import path from 'path';
 import execSh from 'exec-sh';
 import { specmaticJarPathLocal, specmatic } from '../config';
 import { ChildProcess } from 'child_process';
+import { XMLParser } from 'fast-xml-parser';
+import fs from 'fs';
 
 const specmaticJarPath = path.resolve(specmaticJarPathLocal);
 
-const startStub = (host?: string, port?: string, stubDir?: string) : Promise<ChildProcess> => {
+const startStub = (host?: string, port?: string, stubDir?: string): Promise<ChildProcess> => {
     const stubs = path.resolve(stubDir + '');
 
     var cmd = `java -jar ${specmaticJarPath} stub`;
     if (stubDir) cmd += ` --data=${stubs}`;
     if (host) cmd += ` --host=${host}`;
     if (port) cmd += ` --port=${port}`;
-    console.log(cmd);
+    // console.log(cmd);
 
     console.log('Starting specmatic stub server');
     return new Promise((resolve, _reject) => {
@@ -23,9 +25,10 @@ const startStub = (host?: string, port?: string, stubDir?: string) : Promise<Chi
             }
         });
         javaProcess.stdout.on('data', function (data: String) {
-            console.log('STDOUT: ' + data);
+            // console.log('STDOUT: ' + data);
             if (data.indexOf('Stub server is running') > -1) {
-              resolve(javaProcess);
+                console.log('STDOUT: ' + data);
+                resolve(javaProcess);
             }
         });
         javaProcess.stderr.on('data', function (data: String) {
@@ -35,42 +38,65 @@ const startStub = (host?: string, port?: string, stubDir?: string) : Promise<Chi
 };
 
 const stopStub = (javaProcess: ChildProcess) => {
-    console.log(`Stopping specmatic server`);
+    console.log(`Stopping specmatic stub server`);
     javaProcess.stdout?.removeAllListeners();
     javaProcess.stderr?.removeAllListeners();
     javaProcess.removeAllListeners('close');
     javaProcess.kill();
 };
 
-const test = (specs?: string, host?: string, port?: string): Promise<boolean> => {
+const test = (host?: string, port?: string, specs?: string): Promise<TestResult | undefined> => {
     const specsPath = path.resolve(specs + '');
 
     var cmd = `java -jar ${specmaticJarPath} test`;
     if (specs) cmd += ` ${specsPath}`;
+    cmd += ' --junitReportDir=dist/test-report';
     if (host) cmd += ` --host=${host}`;
     if (port) cmd += ` --port=${port}`;
-    console.log(cmd);
+    // console.log(cmd);
 
     console.log('Running specmatic tests');
 
+    const reportDir = path.resolve('dist/test-report');
+    fs.rmSync(reportDir, { recursive: true, force: true });
+
     return new Promise((resolve, _reject) => {
-        execSh(cmd, {}, (err: any) => {
-            if (err) {
-                console.error('Specmatic test run failed with error', err);
-            }
-            resolve(err == null);
+        execSh(cmd, { stdio: 'pipe', stderr: 'pipe' }, (err: any) => {
+            // if (err) {
+            //     console.error('Specmatic test run failed with error', err);
+            // }
+            var testCases = parseJunitXML();
+            const total = testCases.length;
+            const success = testCases.filter((testcase: { [id: string]: any }) => testcase['system-out'] && !testcase['failure']).length;
+            const failure = testCases.filter((testcase: { [id: string]: any }) => testcase['failure']).length;
+            var result = new TestResult(total, success, failure);
+            resolve(result);
         });
     });
 };
 
-const setExpectations = (stubPath: string, stubServerBaseUrl?: string) => {
+const showTestResults = (cb: (name: string, result: boolean) => {}) => {
+    var testCases = parseJunitXML();
+    testCases.map(function (testcase: { [id: string]: any }) {
+        var name = testcase['system-out'].trim().replaceAll('\n', '').split('display-name:  Scenario: ')[1].trim();
+        cb(name, !testcase.failure);
+    });
+};
+
+const setExpectations = (stubPath: string, stubServerBaseUrl?: string): Promise<boolean> => {
     const stubResponse = require(path.resolve(stubPath));
 
     console.log('Setting expectations');
-    fetch(`${stubServerBaseUrl ? stubServerBaseUrl : `http://localhost:9000/`}_specmatic/expectations`, {
-        method: 'POST',
-        body: JSON.stringify(stubResponse),
-    }).then(json => console.log(json));
+
+    return new Promise((resolve, _reject) => {
+        fetch(`${stubServerBaseUrl ? stubServerBaseUrl : `http://localhost:9000/`}_specmatic/expectations`, {
+            method: 'POST',
+            body: JSON.stringify(stubResponse),
+        }).then(json => {
+            console.log('Setting expectations complete');
+            resolve(true);
+        });
+    });
 };
 
 const printJarVersion = () => {
@@ -81,4 +107,25 @@ const printJarVersion = () => {
     });
 };
 
-export { startStub, stopStub, test, setExpectations, printJarVersion };
+const parseJunitXML = () => {
+    const reportPath = path.resolve('dist/test-report/TEST-junit-jupiter.xml');
+    var data = fs.readFileSync(reportPath);
+    const parser = new XMLParser();
+    var resultXml = parser.parse(data);
+    resultXml.testsuite.testcase = Array.isArray(resultXml.testsuite.testcase) ? resultXml.testsuite.testcase : [resultXml.testsuite.testcase];
+    return resultXml.testsuite.testcase;
+};
+
+class TestResult {
+    count: number;
+    success: number;
+    failure: number;
+
+    constructor(count: number, success: number, failure: number) {
+        this.count = count;
+        this.success = success;
+        this.failure = failure;
+    }
+}
+
+export { startStub, stopStub, test, setExpectations, printJarVersion, showTestResults };