specmatic 0.68.0 → 0.68.2

package/dist/bin/core.js

@@ -4,55 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _execSh = _interopRequireDefault(require("exec-sh"));
-var _path = _interopRequireDefault(require("path"));
-var _config = require("../config");
 var _logger = _interopRequireDefault(require("../common/logger"));
-var _child_process = require("child_process");
-var _fs = _interopRequireDefault(require("fs"));
+var _runner = _interopRequireDefault(require("../common/runner"));
 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); }); }; }
-var callSpecmaticCli = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(function* (args) {
-    var specmaticJarPath = yield getSpecmaticJarPath();
-    _logger.default.debug("CLI: Specmatic jar path: ".concat(specmaticJarPath));
-    var cliArgs = (args || process.argv).slice(2).join(' ');
-    _logger.default.info("CLI: Running with args \"".concat(cliArgs, "\""));
-    (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " ").concat(cliArgs), {}, err => {
-      if (err) {
-        _logger.default.info('CLI: Finished with non zero exit code: ', err.code);
-        process.exitCode = err.code;
-      } else {
-        _logger.default.info('CLI: Finished');
-        process.exitCode = 0;
-      }
-    });
-  });
-  return function callSpecmaticCli(_x) {
-    return _ref.apply(this, arguments);
-  };
-}();
-function getSpecmaticJarPath() {
-  return new Promise((resolve, _reject) => {
-    var specmaticJarPath = _path.default.resolve(_config.specmaticJarPathLocal);
-    resolve(specmaticJarPath);
-  }).then(specmaticJarPath => {
-    if (!_fs.default.existsSync(specmaticJarPath)) {
-      return getGlobalSpecmaticJarPath();
+var callSpecmaticCli = args => {
+  var cliArgs = (args || process.argv).slice(2).join(' ');
+  _logger.default.info("CLI: Running with args \"".concat(cliArgs, "\""));
+  (0, _runner.default)(cliArgs, err => {
+    if (err) {
+      _logger.default.info('CLI: Finished with non zero exit code: ', err.code);
+      process.exitCode = err.code;
     } else {
-      return specmaticJarPath;
+      _logger.default.info('CLI: Finished');
+      process.exitCode = 0;
     }
+  }, message => {
+    console.log("".concat(message));
   });
-}
-function getGlobalSpecmaticJarPath() {
-  return new Promise((resolve, _reject) => {
-    (0, _child_process.exec)('npm root -g', (_err, stdout) => {
-      var npmGlobalModuleInstallPath = stdout.replace(/\n/g, '');
-      var jarPath = _path.default.join(npmGlobalModuleInstallPath, 'specmatic', _config.specmaticJarName);
-      resolve(jarPath);
-    });
-  });
-}
+};
 var _default = callSpecmaticCli;
 exports.default = _default;

package/dist/common/runner.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _execSh = _interopRequireDefault(require("exec-sh"));
+var _path = _interopRequireDefault(require("path"));
+var _config = require("../config");
+var _logger = _interopRequireDefault(require("../common/logger"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var callSpecmatic = (args, done, onOutput) => {
+  var _javaProcess$stdout, _javaProcess$stderr;
+  var rootPath = _path.default.resolve(__dirname, '..', '..');
+  var specmaticJarPath = _path.default.resolve(rootPath, _config.specmaticJarName);
+  _logger.default.debug("CLI: Specmatic jar path: ".concat(specmaticJarPath));
+  var javaProcess = (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " ").concat(args), {
+    stdio: 'pipe',
+    stderr: 'pipe'
+  }, done);
+  (_javaProcess$stdout = javaProcess.stdout) === null || _javaProcess$stdout === void 0 ? void 0 : _javaProcess$stdout.on('data', function (data) {
+    onOutput("".concat(data), false);
+  });
+  (_javaProcess$stderr = javaProcess.stderr) === null || _javaProcess$stderr === void 0 ? void 0 : _javaProcess$stderr.on('data', function (data) {
+    onOutput("".concat(data), true);
+  });
+  return javaProcess;
+};
+var _default = callSpecmatic;
+exports.default = _default;

package/dist/config.js

@@ -3,11 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.specmaticJarPathRemote = exports.specmaticJarPathLocal = exports.specmaticJarName = exports.specmatic = void 0;
+exports.specmaticJarPathRemote = exports.specmaticJarName = exports.specmatic = void 0;
 var specmaticJarName = 'specmatic.jar';
 exports.specmaticJarName = specmaticJarName;
-var specmaticJarPathLocal = "./node_modules/specmatic/".concat(specmaticJarName);
-exports.specmaticJarPathLocal = specmaticJarPathLocal;
 var specmaticJarPathRemote = 'https://github.com/znsio/specmatic/releases/download/0.24.2/specmatic.jar';
 exports.specmaticJarPathRemote = specmaticJarPathRemote;
 var specmatic = 'specmatic.json';

package/dist/lib/index.js

@@ -6,44 +6,39 @@ Object.defineProperty(exports, "__esModule", {
 exports.test = exports.stopStub = exports.startStub = exports.showTestResults = exports.setExpectations = exports.printJarVersion = void 0;
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 var _path = _interopRequireDefault(require("path"));
-var _execSh = _interopRequireDefault(require("exec-sh"));
-var _config = require("../config");
 var _fastXmlParser = require("fast-xml-parser");
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = _interopRequireDefault(require("../common/logger"));
+var _runner = _interopRequireDefault(require("../common/runner"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-var specmaticJarPath = _path.default.resolve(_config.specmaticJarPathLocal);
 var startStub = (host, port, stubDir) => {
   var stubs = _path.default.resolve(stubDir + '');
-  var cmd = "java -jar ".concat(specmaticJarPath, " stub");
+  var cmd = "stub";
   if (stubDir) cmd += " --data=".concat(stubs);
   if (host) cmd += " --host=".concat(host);
   if (port) cmd += " --port=".concat(port);
   _logger.default.info('Stub: Starting server');
   _logger.default.debug("Stub: Executing \"".concat(cmd, "\""));
   return new Promise((resolve, reject) => {
-    var javaProcess = (0, _execSh.default)(cmd, {
-      stdio: 'pipe',
-      stderr: 'pipe'
-    }, err => {
+    var javaProcess = (0, _runner.default)(cmd, err => {
       if (err) {
         _logger.default.error("Stub: Exited with error ".concat(err));
       }
-    });
-    javaProcess.stdout.on('data', function (data) {
-      if (data.indexOf('Stub server is running') > -1) {
-        _logger.default.info("Stub: ".concat(data));
-        resolve(javaProcess);
-      } else if (data.indexOf('Address already in use') > -1) {
-        _logger.default.error("Stub: ".concat(data));
-        reject();
+    }, (message, error) => {
+      if (!error) {
+        if (message.indexOf('Stub server is running') > -1) {
+          _logger.default.info("Stub: ".concat(message));
+          resolve(javaProcess);
+        } else if (message.indexOf('Address already in use') > -1) {
+          _logger.default.error("Stub: ".concat(message));
+          reject();
+        } else {
+          _logger.default.debug("Stub: ".concat(message));
+        }
       } else {
-        _logger.default.debug("Stub: ".concat(data));
+        _logger.default.error("Stub: ".concat(message));
       }
     });
-    javaProcess.stderr.on('data', function (data) {
-      _logger.default.error("Stub: ".concat(data));
-    });
   });
 };
 exports.startStub = startStub;
@@ -59,7 +54,7 @@ var stopStub = javaProcess => {
 exports.stopStub = stopStub;
 var test = (host, port, specs) => {
   var specsPath = _path.default.resolve(specs + '');
-  var cmd = "java -jar ".concat(specmaticJarPath, " test");
+  var cmd = "test";
   if (specs) cmd += " ".concat(specsPath);
   cmd += ' --junitReportDir=dist/test-report';
   if (host) cmd += " --host=".concat(host);
@@ -72,13 +67,8 @@ var test = (host, port, specs) => {
     force: true
   });
   return new Promise((resolve, _reject) => {
-    var javaProcess = (0, _execSh.default)(cmd, {
-      stdio: 'pipe',
-      stderr: 'pipe'
-    }, err => {
-      if (err) {
-        _logger.default.error("Test: Failed with error ".concat(err));
-      }
+    (0, _runner.default)(cmd, err => {
+      if (err) _logger.default.error("Test: Failed with error ".concat(err));
       var testCases = parseJunitXML();
       var total = testCases.length;
       var success = testCases.filter(testcase => testcase['system-out'] && !testcase['failure']).length;
@@ -89,12 +79,8 @@ var test = (host, port, specs) => {
         failure
       };
       resolve(result);
-    });
-    javaProcess.stdout.on('data', function (data) {
-      _logger.default.debug("Test: ".concat(data));
-    });
-    javaProcess.stderr.on('data', function (data) {
-      _logger.default.error("Test: ".concat(data));
+    }, (message, error) => {
+      _logger.default[error ? 'error' : 'debug']("Test: ".concat(message));
     });
   });
 };
@@ -127,13 +113,13 @@ var setExpectations = (stubPath, stubServerBaseUrl) => {
 };
 exports.setExpectations = setExpectations;
 var printJarVersion = () => {
-  var cmd = "java -jar ".concat(specmaticJarPath, " --version");
+  var cmd = "--version";
   _logger.default.info('Print Jar Version: Running');
   _logger.default.debug("Print Jar Version: Executing \"".concat(cmd, "\""));
-  (0, _execSh.default)(cmd, {}, err => {
-    if (err) {
-      _logger.default.error("Print Jar Version: Failed with error ".concat(err));
-    }
+  (0, _runner.default)(cmd, err => {
+    if (err) _logger.default.error("Print Jar Version: Failed with error ".concat(err));
+  }, (message, error) => {
+    if (error) _logger.default.error("Print Jar Version: ".concat(message));else console.log("".concat(message));
   });
 };
 exports.printJarVersion = printJarVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmatic",
-  "version": "0.68.0",
+  "version": "0.68.2",
   "description": "Node wrapper for Specmatic",
   "main": "dist/index.js",
   "scripts": {

package/src/bin/__tests__/core.ts

@@ -1,34 +1,33 @@
 import execSh from 'exec-sh';
 import path from 'path';
 import callSpecmaticCli from '../core';
-import { specmaticJarName, specmaticJarPathLocal } from '../../config';
+import { specmaticJarName } from '../../config';
 import fs from 'fs';
-import { exec } from 'child_process';
+import { ChildProcess } from 'child_process';
+import { mock as jestMock, mockReset } from 'jest-mock-extended';
+import { Readable } from 'stream';
 
 jest.mock('exec-sh');
 jest.mock('child_process');
-const execMock = exec as unknown as jest.Mock;
+
+const javaProcessMock = jestMock<ChildProcess>();
+const readableMock = jestMock<Readable>();
+javaProcessMock.stdout = readableMock;
+javaProcessMock.stderr = readableMock;
 
 beforeEach(() => {
     jest.resetAllMocks();
+    mockReset(javaProcessMock);
+    mockReset(readableMock);
 });
 
 test('pass all wrapper arguments to the jar', async () => {
-    jest.spyOn(fs, 'existsSync').mockReturnValue(true);
-    const testArgs = ['node', 'index.js', 'stub', '*.specmatic', '--data', 'src/mocks', '--host', 'localhost', '--port', '8000'];
-    await callSpecmaticCli(testArgs);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} ${testArgs.slice(2).join(' ')}`);
-    expect(execSh).toHaveBeenCalledTimes(1);
-});
+    execSh.mockReturnValue(javaProcessMock);
 
-test('look for jar in specmatic globally installled directory when run from global install', async () => {
-    jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+    jest.spyOn(fs, 'existsSync').mockReturnValue(true);
     const testArgs = ['node', 'index.js', 'stub', '*.specmatic', '--data', 'src/mocks', '--host', 'localhost', '--port', '8000'];
-    const NPM_GLOBAL_PATH = '/npm/global/path';
-    setTimeout(() => {
-        execMock.mock.calls[0][1](0, NPM_GLOBAL_PATH);
-    }, 0);
-    await callSpecmaticCli(testArgs);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(NPM_GLOBAL_PATH, 'specmatic', specmaticJarName)} ${testArgs.slice(2).join(' ')}`);
+    callSpecmaticCli(testArgs);
+    const specmaticJarPath = path.resolve(__dirname, '..', '..', '..', specmaticJarName);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPath)} ${testArgs.slice(2).join(' ')}`);
     expect(execSh).toHaveBeenCalledTimes(1);
 });

package/src/bin/core.ts

@@ -1,47 +1,24 @@
-import execSh from 'exec-sh';
-import path from 'path';
-import { specmaticJarPathLocal, specmaticJarName } from '../config';
 import logger from '../common/logger';
-import { exec } from 'child_process';
-import fs from 'fs';
+import callSpecmatic from '../common/runner';
 
-const callSpecmaticCli = async (args?: string[]) => {
-    const specmaticJarPath = await getSpecmaticJarPath();
-    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
+const callSpecmaticCli = (args?: string[]) => {
     const cliArgs = (args || process.argv).slice(2).join(' ');
     logger.info(`CLI: Running with args "${cliArgs}"`);
-    execSh(`java -jar ${specmaticJarPath} ${cliArgs}`, {}, (err: any) => {
-        if (err) {
-            logger.info('CLI: Finished with non zero exit code: ', err.code);
-            process.exitCode = err.code;
-        } else {
-            logger.info('CLI: Finished');
-            process.exitCode = 0;
+    callSpecmatic(
+        cliArgs,
+        (err?: any) => {
+            if (err) {
+                logger.info('CLI: Finished with non zero exit code: ', err.code);
+                process.exitCode = err.code;
+            } else {
+                logger.info('CLI: Finished');
+                process.exitCode = 0;
+            }
+        },
+        message => {
+            console.log(`${message}`);
         }
-    });
+    );
 };
 
-function getSpecmaticJarPath() {
-    return new Promise<string>((resolve, _reject) => {
-        let specmaticJarPath = path.resolve(specmaticJarPathLocal);
-        resolve(specmaticJarPath);
-    }).then(specmaticJarPath => {
-        if (!fs.existsSync(specmaticJarPath)) {
-            return getGlobalSpecmaticJarPath();
-        } else {
-            return specmaticJarPath;
-        }
-    });
-}
-
-function getGlobalSpecmaticJarPath() {
-    return new Promise((resolve, _reject) => {
-        exec('npm root -g', (_err, stdout) => {
-            const npmGlobalModuleInstallPath = stdout.replace(/\n/g, '');
-            const jarPath = path.join(npmGlobalModuleInstallPath, 'specmatic', specmaticJarName);
-            resolve(jarPath);
-        });
-    });
-}
-
 export default callSpecmaticCli;

package/src/common/runner.ts

@@ -0,0 +1,21 @@
+import execSh from 'exec-sh';
+import path from 'path';
+import { specmaticJarName } from '../config';
+import logger from '../common/logger';
+import { ChildProcess } from 'child_process';
+
+const callSpecmatic = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
+    const rootPath = path.resolve(__dirname, '..', '..');
+    const specmaticJarPath = path.resolve(rootPath, specmaticJarName);
+    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
+    const javaProcess = execSh(`java -jar ${specmaticJarPath} ${args}`, { stdio: 'pipe', stderr: 'pipe' }, done);
+    javaProcess.stdout?.on('data', function (data: String) {
+        onOutput(`${data}`, false);
+    });
+    javaProcess.stderr?.on('data', function (data: String) {
+        onOutput(`${data}`, true);
+    });
+    return javaProcess;
+};
+
+export default callSpecmatic;

package/src/config.ts

@@ -1,4 +1,3 @@
 export const specmaticJarName = 'specmatic.jar';
-export const specmaticJarPathLocal = `./node_modules/specmatic/${specmaticJarName}`;
 export const specmaticJarPathRemote = 'https://github.com/znsio/specmatic/releases/download/0.24.2/specmatic.jar';
 export const specmatic = 'specmatic.json';

package/src/lib/__tests__/index.ts

@@ -8,7 +8,7 @@ import { copyFileSync, mkdirSync, existsSync } from 'fs';
 import fs from 'fs';
 
 import * as specmatic from '../../';
-import { specmaticJarPathLocal } from '../../config';
+import { specmaticJarName } from '../../config';
 import mockStub from '../../../test-resources/sample-mock-stub.json';
 
 jest.mock('exec-sh');
@@ -16,6 +16,7 @@ jest.mock('node-fetch');
 
 const fetchMock = fetch as unknown as jest.Mock;
 
+const SPECMATIC_JAR_PATH = path.resolve(__dirname, '..', '..', '..', specmaticJarName);
 const STUB_PATH = 'test-resources/sample-mock-stub.json';
 const CONTRACT_YAML_FILE_PATH = './contracts';
 const STUB_DIR_PATH = './data';
@@ -42,7 +43,7 @@ test('startStub method starts the specmatic stub server', async () => {
 
     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}`
+        `java -jar ${path.resolve(SPECMATIC_JAR_PATH)} stub --data=${path.resolve(STUB_DIR_PATH)} --host=${HOST} --port=${PORT}`
     );
 });
 
@@ -54,7 +55,7 @@ test('startStub method notifies when start fails due to port not available', asy
 
     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}`
+        `java -jar ${path.resolve(SPECMATIC_JAR_PATH)} stub --data=${path.resolve(STUB_DIR_PATH)} --host=${HOST} --port=${PORT}`
     );
 });
 
@@ -65,7 +66,7 @@ test('startStub method stubDir is optional', async () => {
     await expect(specmatic.startStub(HOST, PORT)).resolves.toBe(javaProcessMock);
 
     expect(execSh).toHaveBeenCalledTimes(1);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --host=${HOST} --port=${PORT}`);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(SPECMATIC_JAR_PATH)} stub --host=${HOST} --port=${PORT}`);
 });
 
 test('startStub method host and port are optional', async () => {
@@ -75,7 +76,7 @@ test('startStub method host and port are optional', async () => {
     await expect(specmatic.startStub()).resolves.toBe(javaProcessMock);
 
     expect(execSh).toHaveBeenCalledTimes(1);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub`);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(SPECMATIC_JAR_PATH)} stub`);
 });
 
 test('stopStub method stops any running stub server', () => {
@@ -97,7 +98,7 @@ test('test runs the contract tests', async function () {
 
     expect(execSh).toHaveBeenCalledTimes(1);
     expect(execSh.mock.calls[0][0]).toBe(
-        `java -jar ${path.resolve(specmaticJarPathLocal)} test ${path.resolve(
+        `java -jar ${path.resolve(SPECMATIC_JAR_PATH)} test ${path.resolve(
             CONTRACT_YAML_FILE_PATH
         )} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`
     );
@@ -113,7 +114,7 @@ test('test runs the contract tests with host and port optional', async function
     await expect(specmatic.test()).resolves.toBeTruthy();
 
     expect(execSh).toHaveBeenCalledTimes(1);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report`);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(SPECMATIC_JAR_PATH)} test --junitReportDir=dist/test-report`);
 });
 
 test('test runs the contract tests with contracts path optional', async function () {
@@ -127,7 +128,7 @@ test('test runs the contract tests with contracts path optional', async function
 
     expect(execSh).toHaveBeenCalledTimes(1);
     expect(execSh.mock.calls[0][0]).toBe(
-        `java -jar ${path.resolve(specmaticJarPathLocal)} test --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`
+        `java -jar ${path.resolve(SPECMATIC_JAR_PATH)} test --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`
     );
 });
 
@@ -174,10 +175,12 @@ test('test invocation makes sure previous junit report if any is deleted', async
 });
 
 test('printJarVersion', () => {
+    execSh.mockReturnValue(javaProcessMock);
+
     specmatic.printJarVersion();
 
     expect(execSh).toHaveBeenCalledTimes(1);
-    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} --version`);
+    expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(SPECMATIC_JAR_PATH)} --version`);
 });
 
 test('setExpectations with default baseUrl', async () => {

package/src/lib/index.ts

@@ -1,18 +1,15 @@
 import fetch from 'node-fetch';
 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';
 import logger from '../common/logger';
-
-const specmaticJarPath = path.resolve(specmaticJarPathLocal);
+import callSpecmatic from '../common/runner';
 
 const startStub = (host?: string, port?: string, stubDir?: string): Promise<ChildProcess> => {
     const stubs = path.resolve(stubDir + '');
 
-    var cmd = `java -jar ${specmaticJarPath} stub`;
+    var cmd = `stub`;
     if (stubDir) cmd += ` --data=${stubs}`;
     if (host) cmd += ` --host=${host}`;
     if (port) cmd += ` --port=${port}`;
@@ -21,25 +18,29 @@ const startStub = (host?: string, port?: string, stubDir?: string): Promise<Chil
     logger.debug(`Stub: Executing "${cmd}"`);
 
     return new Promise((resolve, reject) => {
-        const javaProcess = execSh(cmd, { stdio: 'pipe', stderr: 'pipe' }, (err: any) => {
-            if (err) {
-                logger.error(`Stub: Exited with error ${err}`);
+        const javaProcess = callSpecmatic(
+            cmd,
+            (err: any) => {
+                if (err) {
+                    logger.error(`Stub: Exited with error ${err}`);
+                }
+            },
+            (message, error) => {
+                if (!error) {
+                    if (message.indexOf('Stub server is running') > -1) {
+                        logger.info(`Stub: ${message}`);
+                        resolve(javaProcess);
+                    } else if (message.indexOf('Address already in use') > -1) {
+                        logger.error(`Stub: ${message}`);
+                        reject();
+                    } else {
+                        logger.debug(`Stub: ${message}`);
+                    }
+                } else {
+                    logger.error(`Stub: ${message}`);
+                }
             }
-        });
-        javaProcess.stdout.on('data', function (data: String) {
-            if (data.indexOf('Stub server is running') > -1) {
-                logger.info(`Stub: ${data}`);
-                resolve(javaProcess);
-            } else if (data.indexOf('Address already in use') > -1) {
-                logger.error(`Stub: ${data}`);
-                reject();
-            } else {
-                logger.debug(`Stub: ${data}`);
-            }
-        });
-        javaProcess.stderr.on('data', function (data: String) {
-            logger.error(`Stub: ${data}`);
-        });
+        );
     });
 };
 
@@ -55,7 +56,7 @@ const stopStub = (javaProcess: ChildProcess) => {
 const test = (host?: string, port?: string, specs?: string): Promise<{ [k: string]: number } | undefined> => {
     const specsPath = path.resolve(specs + '');
 
-    var cmd = `java -jar ${specmaticJarPath} test`;
+    var cmd = `test`;
     if (specs) cmd += ` ${specsPath}`;
     cmd += ' --junitReportDir=dist/test-report';
     if (host) cmd += ` --host=${host}`;
@@ -68,23 +69,21 @@ const test = (host?: string, port?: string, specs?: string): Promise<{ [k: strin
     fs.rmSync(reportDir, { recursive: true, force: true });
 
     return new Promise((resolve, _reject) => {
-        const javaProcess = execSh(cmd, { stdio: 'pipe', stderr: 'pipe' }, (err: any) => {
-            if (err) {
-                logger.error(`Test: Failed with error ${err}`);
+        callSpecmatic(
+            cmd,
+            (err: any) => {
+                if (err) logger.error(`Test: 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 = { total, success, failure };
+                resolve(result);
+            },
+            (message, error) => {
+                logger[error ? 'error' : 'debug'](`Test: ${message}`);
             }
-            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 = { total, success, failure };
-            resolve(result);
-        });
-        javaProcess.stdout.on('data', function (data: String) {
-            logger.debug(`Test: ${data}`);
-        });
-        javaProcess.stderr.on('data', function (data: String) {
-            logger.error(`Test: ${data}`);
-        });
+        );
     });
 };
 
@@ -120,15 +119,20 @@ const setExpectations = (stubPath: string, stubServerBaseUrl?: string): Promise<
 };
 
 const printJarVersion = () => {
-    const cmd = `java -jar ${specmaticJarPath} --version`;
+    const cmd = `--version`;
     logger.info('Print Jar Version: Running');
     logger.debug(`Print Jar Version: Executing "${cmd}"`);
 
-    execSh(cmd, {}, (err: any) => {
-        if (err) {
-            logger.error(`Print Jar Version: Failed with error ${err}`);
+    callSpecmatic(
+        cmd,
+        (err: any) => {
+            if (err) logger.error(`Print Jar Version: Failed with error ${err}`);
+        },
+        (message, error) => {
+            if (error) logger.error(`Print Jar Version: ${message}`);
+            else console.log(`${message}`);
         }
-    });
+    );
 };
 
 const parseJunitXML = () => {