specmatic 0.65.1 → 1.0.0

package/README.md

@@ -1,10 +1,6 @@
-[Specmatic](https://specmatic.in/) is a contract driven development tool that leverages API Specifications, such as [OpenAPI](https://www.openapis.org/), as executable specification. <br />
+# Specmatic Framework Node Module
 
-[![Specmatic - Contract Driven Development](http://img.youtube.com/vi/3HPgpvd8MGg/0.jpg)](http://www.youtube.com/watch?v=3HPgpvd8MGg "Specmatic - Contract Driven Development - Micro-services done right without the pain of integration")
-
-## Thin Wrapper
-
-Specmatic is a **standalone executable** that is **agnostic to programming languages and technology stacks**. This node module is a thin wrapper over the [standalone executable jar](https://specmatic.in/getting_started.html#setup). All core capabilities are in the main [Specmatic project](https://github.com/znsio/specmatic). The purpose of this wrapper module is to act as a convenience to help with below aspects.
+This node module is a thin wrapper over the [standalone executable jar](https://specmatic.in/getting_started.html#setup). All core capabilities are in the main [Specmatic project](https://github.com/znsio/specmatic). The purpose of this wrapper module is to act as a convenience to help with below aspects.
 * Easy installation and upgrade of the jar file in node projects through npm
 * JS helper library which provides to do various setup steps like start, stop the specmatic stub server, installing specs etc. These helpers methods can be used inside a setup file inside a javascript project programmatically instead of using cli scripts.
 
@@ -25,37 +21,31 @@ Tests for Free – Specmatic parses your API Specification files and based on th
 
 Check [Documentation](https://specmatic.in/documentation.html) for more information on cli commands and arguments.
 
-## Test helper library
+## Programmatic Access
+
+Specmatic JS library exposes some of the commands as methods that can be run programmatically from any javascript testing framework, during setup or test phases.
 
 ```
 import { 
-    startStubServer,
-    runContractTests, 
-    loadDynamicStub, 
-    installContracts,
-    setSpecmaticEnvironment
+    startStub,
+    stopStub,
+    test, 
+    setExpecations,
+    printJarVersion
 } from 'specmatic';
 ```
 
-Specmatic JS library exposes methods which can be used in your JS project to setup the tests, as well as do advanced things like load stubs dynamically. These can be used to programmatically run specmatic commands from any javascript testing framework, during setup or test phases.
-
-`startStubServer(specmaticDir: string, stubDir: string, host: string, port: string)` <br />
+`startStub(host?: string, port?: string, stubDir?: string) : Promise<ChildProcess>` <br />
 method to start the stub server.
 
-`runContractTests(specmaticDir: string, host: string, port: string)` <br />
-Alias: `startTestServer` <br />
-method to start test server.
-
-`loadDynamicStub(stubPath: string)` <br />
-Alias: `setExpectations` <br />
-method to load stub dynamically from inside an automated test.
+`stopStub(process: ChildProcess)` <br />
+method to stop the stub server.
 
-`installContracts()` <br />
-Alias: `installSpecs` <br />
-method to install specs in local machine.
+`test(specs?: string, host?: string, port?: string): Promise<boolean>` <br />
+method to run tests.
 
-`setSpecmaticEnvironment = (environmentName: string, environment: Environment) ` <br />
-method to dynamically write new variables or assign values to variables of the environment passed as argument to the function, inside the file 'specmatic.json'.This function expects the file 'specmatic.json' to be in the root directory of your project.
+`setExpectations(stubPath: string, stubServerBaseUrl?: string)` <br />
+method to dynamically set stub expectiona. Stub should be running before invoking this method.
 
 `printSpecmaticJarVersion()` <br />
 method to print the version of specmatic.jar

package/dist/index.js

@@ -3,52 +3,34 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "loadDynamicStub", {
+Object.defineProperty(exports, "startStub", {
   enumerable: true,
   get: function get() {
-    return _lib.loadDynamicStub;
+    return _lib.startStub;
   }
 });
-Object.defineProperty(exports, "setExpectations", {
-  enumerable: true,
-  get: function get() {
-    return _lib.setExpectations;
-  }
-});
-Object.defineProperty(exports, "startStubServer", {
-  enumerable: true,
-  get: function get() {
-    return _lib.startStubServer;
-  }
-});
-Object.defineProperty(exports, "startTestServer", {
-  enumerable: true,
-  get: function get() {
-    return _lib.startTestServer;
-  }
-});
-Object.defineProperty(exports, "runContractTests", {
+Object.defineProperty(exports, "stopStub", {
   enumerable: true,
   get: function get() {
-    return _lib.runContractTests;
+    return _lib.stopStub;
   }
 });
-Object.defineProperty(exports, "installContracts", {
+Object.defineProperty(exports, "test", {
   enumerable: true,
   get: function get() {
-    return _lib.installContracts;
+    return _lib.test;
   }
 });
-Object.defineProperty(exports, "installSpecs", {
+Object.defineProperty(exports, "setExpectations", {
   enumerable: true,
   get: function get() {
-    return _lib.installSpecs;
+    return _lib.setExpectations;
   }
 });
-Object.defineProperty(exports, "setSpecmaticEnvironment", {
+Object.defineProperty(exports, "printJarVersion", {
   enumerable: true,
   get: function get() {
-    return _lib.setSpecmaticEnvironment;
+    return _lib.printJarVersion;
   }
 });
 

package/dist/lib/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.printSpecmaticJarVersion = exports.setExpectations = exports.loadDynamicStub = exports.installSpecs = exports.installContracts = exports.runContractTests = exports.startTestServer = exports.startStubServer = exports.setSpecmaticEnvironment = void 0;
+exports.printJarVersion = exports.setExpectations = exports.test = exports.stopStub = exports.startStub = void 0;
 
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 
@@ -13,98 +13,95 @@ var _execSh = _interopRequireDefault(require("exec-sh"));
 
 var _config = require("../config");
 
-var _fs = _interopRequireDefault(require("fs"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var specmaticJarPath = _path.default.resolve(_config.specmaticJarPathLocal);
 
-var setSpecmaticEnvironment = (environmentName, environment) => {
-  var file = null;
-
-  try {
-    file = require(_path.default.resolve(_config.specmatic));
-
-    for (var environmentVariable in environment) {
-      file.environments[environmentName].variables[environmentVariable] = environment[environmentVariable];
-    }
-
-    _fs.default.writeFileSync(_path.default.resolve(_config.specmatic), JSON.stringify(file, null, 2));
-  } catch (e) {
-    if (e.toString().includes("Cannot find module")) console.log(e.toString(), "\nThe file 'specmatic.json' is not present in the root directory of the project.");else console.log(e);
-  }
-};
-
-exports.setSpecmaticEnvironment = setSpecmaticEnvironment;
-
-var startStubServer = (specmaticDir, stubDir, host, port) => {
-  var specmatics = _path.default.resolve(specmaticDir + '');
-
+var startStub = (host, port, stubDir) => {
   var stubs = _path.default.resolve(stubDir + '');
 
-  console.log("java -jar ".concat(specmaticJarPath, " stub ").concat(specmatics, " --strict --data=").concat(stubs, " --host=").concat(host, " --port=").concat(port));
+  var cmd = "java -jar ".concat(specmaticJarPath, " stub");
+  if (stubDir) cmd += " --data=".concat(stubs);
+  if (host) cmd += " --host=".concat(host);
+  if (port) cmd += " --port=".concat(port);
+  console.log(cmd);
   console.log('Starting specmatic stub server');
-  (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " stub ").concat(specmatics, " --strict --data=").concat(stubs, " --host=").concat(host, " --port=").concat(port), {}, err => {
-    if (err) {
-      console.log('Exit code: ', err.code);
-      process.exit(err.code);
-    }
+  return new Promise((resolve, _reject) => {
+    var javaProcess = (0, _execSh.default)(cmd, {
+      stdio: 'pipe',
+      stderr: 'pipe'
+    }, err => {
+      if (err) {
+        console.error('Specmatic stub server exited with error', err);
+      }
+    });
+    javaProcess.stdout.on('data', function (data) {
+      console.log('STDOUT: ' + data);
+
+      if (data.indexOf('Stub server is running') > -1) {
+        resolve(javaProcess);
+      }
+    });
+    javaProcess.stderr.on('data', function (data) {
+      console.log('STDERR: ' + data);
+    });
   });
 };
 
-exports.startStubServer = startStubServer;
+exports.startStub = startStub;
 
-var startTestServer = (specmaticDir, host, port) => {
-  var specmatics = _path.default.resolve(specmaticDir);
+var stopStub = javaProcess => {
+  var _javaProcess$stdout, _javaProcess$stderr;
 
-  console.log('Running specmatic tests');
-  (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " test ").concat(specmatics, " --host=").concat(host, " --port=").concat(port), {}, err => {
-    if (err) {
-      console.log('Exit code: ', err.code);
-      process.exit(err.code);
-    }
-  });
+  console.log("Stopping specmatic server");
+  (_javaProcess$stdout = javaProcess.stdout) === null || _javaProcess$stdout === void 0 ? void 0 : _javaProcess$stdout.removeAllListeners();
+  (_javaProcess$stderr = javaProcess.stderr) === null || _javaProcess$stderr === void 0 ? void 0 : _javaProcess$stderr.removeAllListeners();
+  javaProcess.removeAllListeners('close');
+  javaProcess.kill();
 };
 
-exports.startTestServer = startTestServer;
-var runContractTests = startTestServer;
-exports.runContractTests = runContractTests;
+exports.stopStub = stopStub;
 
-var installContracts = () => {
-  console.log('Installing contracts');
-  (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " install"), {}, err => {
-    if (err) {
-      console.log('Exit code: ', err.code);
-      process.exit(err.code);
-    }
+var test = (specs, host, port) => {
+  var specsPath = _path.default.resolve(specs + '');
+
+  var cmd = "java -jar ".concat(specmaticJarPath, " test");
+  if (specs) cmd += " ".concat(specsPath);
+  if (host) cmd += " --host=".concat(host);
+  if (port) cmd += " --port=".concat(port);
+  console.log(cmd);
+  console.log('Running specmatic tests');
+  return new Promise((resolve, _reject) => {
+    (0, _execSh.default)(cmd, {}, err => {
+      if (err) {
+        console.error('Specmatic test run failed with error', err);
+      }
+
+      resolve(err == null);
+    });
   });
 };
 
-exports.installContracts = installContracts;
-var installSpecs = installContracts;
-exports.installSpecs = installSpecs;
+exports.test = test;
 
-var loadDynamicStub = (stubPath, stubServerBaseUrl) => {
+var setExpectations = (stubPath, stubServerBaseUrl) => {
   var stubResponse = require(_path.default.resolve(stubPath));
 
-  console.log("setting expectations");
+  console.log('Setting expectations');
   (0, _nodeFetch.default)("".concat(stubServerBaseUrl ? stubServerBaseUrl : "http://localhost:9000/", "_specmatic/expectations"), {
     method: 'POST',
     body: JSON.stringify(stubResponse)
-  }).then(res => res.json()).then(json => console.log(json));
+  }).then(json => console.log(json));
 };
 
-exports.loadDynamicStub = loadDynamicStub;
-var setExpectations = loadDynamicStub;
 exports.setExpectations = setExpectations;
 
-var printSpecmaticJarVersion = () => {
+var printJarVersion = () => {
   (0, _execSh.default)("java -jar ".concat(specmaticJarPath, " --version"), {}, err => {
     if (err) {
-      console.log('Exit code: ', err.code);
-      process.exit(err.code);
+      console.error('Could not print specmatic version', err);
     }
   });
 };
 
-exports.printSpecmaticJarVersion = printSpecmaticJarVersion;
+exports.printJarVersion = printJarVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmatic",
-  "version": "0.65.1",
+  "version": "1.0.0",
   "description": "Node wrapper for Specmatic",
   "main": "dist/index.js",
   "scripts": {
@@ -44,6 +44,7 @@
   },
   "devDependencies": {
     "@types/jest": "^26.0.14",
-    "jest": "^26.4.2"
+    "jest": "^26.4.2",
+    "jest-mock-extended": "^3.0.4"
   }
 }

package/src/bin/__tests__/core.ts

@@ -10,4 +10,4 @@ test('arguments to be passed correctly to Specmatic lib', () => {
   startSpecmaticServer(testArgs);
   expect(execSh.mock.calls[0][0]).toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} ${testArgs.slice(2).join(' ')}`);
   expect(execSh).toHaveBeenCalledTimes(1);
-});
+});

package/src/index.ts

@@ -1,10 +1,7 @@
 export {
-    loadDynamicStub,
+    startStub,
+    stopStub,
+    test,
     setExpectations,
-    startStubServer,
-    startTestServer,
-    runContractTests,
-    installContracts,
-    installSpecs,
-    setSpecmaticEnvironment
-} from './lib';
+    printJarVersion
+} from './lib';

package/src/lib/__tests__/index.ts

@@ -1,10 +1,14 @@
 import execSh from 'exec-sh';
 import fetch from 'node-fetch';
 import path from 'path';
-import { setSpecmaticEnvironment, startStubServer, Environment, startTestServer, runContractTests, loadDynamicStub, printSpecmaticJarVersion, setExpectations, installContracts, installSpecs } from '../';
-import { specmaticJarPathLocal, specmatic } from '../../config';
-import mockStub from '../../../mockStub.json';
+import { ChildProcess } from 'child_process';
+import { mock as jestMock } from 'jest-mock-extended';
+import { Readable } from "stream";
 
+import * as specmatic from '../';
+import { startStub, stopStub, printJarVersion, setExpectations } from '../';
+import { specmaticJarPathLocal } from '../../config';
+import mockStub from '../../../mockStub.json';
 
 jest.mock('exec-sh');
 jest.mock('node-fetch');
@@ -13,83 +17,85 @@ const contractsPath = './contracts';
 const stubDataPath = './data';
 const host = 'localhost';
 const port = '8000';
-
-
-const checkSpecmaticEnvironment = (environmentName: string, environment: Environment) => {
-  let flag = false
-  try {
-    let file = require(path.resolve(specmatic))
-    for (let environmentVariable in environment) flag = file.environments[environmentName].variables[environmentVariable] == environment[environmentVariable]
-  } catch (e) { console.log(e) }
-  return flag
-}
+const javaProcessMock = jestMock<ChildProcess>();
+const readableMock = jestMock<Readable>();
+javaProcessMock.stdout = readableMock;
+javaProcessMock.stderr = readableMock;
 
 beforeEach(() => {
   execSh.mockReset();
   fetch.mockReset();
 });
 
-test('startStubServer method starts the specmatic stub server', () => {
-  startStubServer(contractsPath, stubDataPath, host, port);
+test('startStub method starts the specmatic stub server', async () => {
+  execSh.mockReturnValue(javaProcessMock);
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub ${path.resolve(contractsPath)} --strict --data=${path.resolve(stubDataPath)} --host=${host} --port=${port}`);
-});
+  startStub(host, port, stubDataPath).then(javaProcess => {
+    expect(javaProcess).toBe(javaProcessMock);
+  })
 
-test('startTestServer runs the contract tests', () => {
-  startTestServer(contractsPath, host, port);
+  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)} test ${path.resolve(contractsPath)} --host=${host} --port=${port}`);
+  .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --data=${path.resolve(stubDataPath)} --host=${host} --port=${port}`);
 });
 
-test('runContractTests runs the contract tests', () => {
-  runContractTests(contractsPath, host, port);
+test('startStub method stubDir is optional', async () => {
+  execSh.mockReturnValue(javaProcessMock);
+
+  startStub(host, port).then(javaProcess => {
+    expect(javaProcess).toBe(javaProcessMock);
+  })
+
+  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)} test ${path.resolve(contractsPath)} --host=${host} --port=${port}`);
+    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub --host=${host} --port=${port}`);
 });
 
+test('startStub method host and port are optional', async () => {
+  execSh.mockReturnValue(javaProcessMock);
+
+  startStub().then(javaProcess => {
+    expect(javaProcess).toBe(javaProcessMock);
+  })
 
-test('installContracts installs contracts to local', () => {
-  installContracts();
+  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)} install`);
+    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} stub`);
 });
 
-test('installSpecs installs contracts to local', () => {
-  installSpecs();
+test('stopStub method stops any running stub server', () => {
+  stopStub(javaProcessMock);
 
-  expect(execSh).toHaveBeenCalledTimes(1);
-  expect(execSh.mock.calls[0][0])
-    .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} install`);
+  expect(readableMock.removeAllListeners).toHaveBeenCalledTimes(2);
+  expect(javaProcessMock.removeAllListeners).toHaveBeenCalledTimes(1);
+  expect(javaProcessMock.kill).toHaveBeenCalledTimes(1);
 });
 
-test('printSpecmaticJarVersion', () => {
-  printSpecmaticJarVersion();
+test('test runs the contract tests', function (done) {
+    specmatic.test(contractsPath, host, port).then(result => {
+      expect(result).toBeTruthy();
+      done();
+    });
+    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}`);
+  });
+
+test('printJarVersion', () => {
+  printJarVersion();
 
   expect(execSh).toHaveBeenCalledTimes(1);
   expect(execSh.mock.calls[0][0])
     .toBe(`java -jar ${path.resolve(specmaticJarPathLocal)} --version`);
 });
 
-test('loadDynamicStub with default baseUrl', () => {
-  fetch.mockReturnValue(Promise.resolve("{}"));
-  loadDynamicStub(path.resolve('./mockStub.json'));
-
-  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 default baseUrl', () => {
   fetch.mockReturnValue(Promise.resolve("{}"));
   setExpectations(path.resolve('./mockStub.json'));
@@ -102,19 +108,6 @@ test('setExpectations with default baseUrl', () => {
   });
 });
 
-test('loadDynamicStub with a different baseUrl for the stub server', () => {
-  fetch.mockReturnValue(Promise.resolve("{}"));
-  const stubServerBaseUrl = 'http://localhost:8000/'
-  loadDynamicStub(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', () => {
   fetch.mockReturnValue(Promise.resolve("{}"));
   const stubServerBaseUrl = 'http://localhost:8000/'
@@ -127,19 +120,3 @@ test('setExpectations with a different baseUrl for the stub server', () => {
     body: JSON.stringify(mockStub)
   });
 });
-
-test('setSpecmaticEnvironment updates the environment variable value in the specmatic.json file', () => {
-  const variableObj1: Record<string, string> = { "key1": "updated-value1", "key2": "updated-value2", "key3": "updated-value3", "key4": "updated-value4" }
-  const variableObj2: Record<string, string> = { "key1": "initial-value1", "key2": "initial-value2", "key3": "initial-value3", "key4": "initial-value4" }
-  setSpecmaticEnvironment("local", variableObj1)
-  expect(checkSpecmaticEnvironment("local", variableObj1)).toBe(true)
-  setSpecmaticEnvironment("local", variableObj2)
-  expect(checkSpecmaticEnvironment("local", variableObj2)).toBe(true)
-});
-
-test('setSpecmaticEnvironment does not updates the environment variable value , when the specified environment name is not present inside specmatic.json file', () => {
-  const variableObj1: Record<string, string> = { "key1": "updated-value1", "key2": "updated-value2", "key3": "updated-value3", "key4": "updated-value4" }
-  setSpecmaticEnvironment("production", variableObj1)
-  expect(checkSpecmaticEnvironment("production", variableObj1)).toBe(false)
-});
-

package/src/lib/index.ts

@@ -2,92 +2,83 @@ import fetch from 'node-fetch';
 import path from 'path';
 import execSh from 'exec-sh';
 import { specmaticJarPathLocal, specmatic } from '../config';
-import fs from 'fs';
+import { ChildProcess } from 'child_process';
 
 const specmaticJarPath = path.resolve(specmaticJarPathLocal);
-export type Environment = Record<string, string>
 
-export const setSpecmaticEnvironment = (environmentName: string, environment: Environment) => {
-  let file = null
-  try {
-    file = require(path.resolve(specmatic))
-    for (let environmentVariable in environment) file.environments[environmentName].variables[environmentVariable] = environment[environmentVariable]
-    fs.writeFileSync(path.resolve(specmatic), JSON.stringify(file, null, 2))
-  } catch (e) {
-    if (e.toString().includes("Cannot find module")) console.log(e.toString(), "\nThe file 'specmatic.json' is not present in the root directory of the project.")
-    else console.log(e)
-  }
-}
+const startStub = (host?: string, port?: string, stubDir?: string) : Promise<ChildProcess> => {
+    const stubs = path.resolve(stubDir + '');
 
-export const startStubServer = (specmaticDir: string, stubDir: string, host: string, port: string) => {
-  const specmatics = path.resolve(specmaticDir + '');
-  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(`java -jar ${specmaticJarPath} stub ${specmatics} --strict --data=${stubs} --host=${host} --port=${port}`)
-
-  console.log('Starting specmatic stub server')
-  execSh(
-    `java -jar ${specmaticJarPath} stub ${specmatics} --strict --data=${stubs} --host=${host} --port=${port}`
-    , {}, (err: any) => {
-      if (err) {
-        console.log('Exit code: ', err.code);
-        process.exit(err.code);
-      }
+    console.log('Starting specmatic stub server');
+    return new Promise((resolve, _reject) => {
+        const javaProcess = execSh(cmd, { stdio: 'pipe', stderr: 'pipe' }, (err: any) => {
+            if (err) {
+                console.error('Specmatic stub server exited with error', err);
+            }
+        });
+        javaProcess.stdout.on('data', function (data: String) {
+            console.log('STDOUT: ' + data);
+            if (data.indexOf('Stub server is running') > -1) {
+              resolve(javaProcess);
+            }
+        });
+        javaProcess.stderr.on('data', function (data: String) {
+            console.log('STDERR: ' + data);
+        });
     });
-}
+};
 
-export const startTestServer = (specmaticDir: string, host: string, port: string) => {
-  const specmatics = path.resolve(specmaticDir);
+const stopStub = (javaProcess: ChildProcess) => {
+    console.log(`Stopping specmatic server`);
+    javaProcess.stdout?.removeAllListeners();
+    javaProcess.stderr?.removeAllListeners();
+    javaProcess.removeAllListeners('close');
+    javaProcess.kill();
+};
 
-  console.log('Running specmatic tests')
-  execSh(
-    `java -jar ${specmaticJarPath} test ${specmatics} --host=${host} --port=${port}`
-    , {}, (err: any) => {
-      if (err) {
-        console.log('Exit code: ', err.code);
-        process.exit(err.code);
-      }
-    });
-}
+const test = (specs?: string, host?: string, port?: string): Promise<boolean> => {
+    const specsPath = path.resolve(specs + '');
 
-export const runContractTests = startTestServer;
+    var cmd = `java -jar ${specmaticJarPath} test`;
+    if (specs) cmd += ` ${specsPath}`;
+    if (host) cmd += ` --host=${host}`;
+    if (port) cmd += ` --port=${port}`;
+    console.log(cmd);
 
-export const installContracts = () => {
-  console.log('Installing contracts')
-  execSh(
-    `java -jar ${specmaticJarPath} install`
-    , {}, (err: any) => {
-      if (err) {
-        console.log('Exit code: ', err.code);
-        process.exit(err.code);
-      }
-    });
-}
+    console.log('Running specmatic tests');
 
-export const installSpecs = installContracts;
+    return new Promise((resolve, _reject) => {
+        execSh(cmd, {}, (err: any) => {
+            if (err) {
+                console.error('Specmatic test run failed with error', err);
+            }
+            resolve(err == null);
+        });
+    });
+};
 
-export const loadDynamicStub = (stubPath: string, stubServerBaseUrl?: string) => {
-  const stubResponse = require(path.resolve(stubPath));
+const setExpectations = (stubPath: string, stubServerBaseUrl?: string) => {
+    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(res => res.json())
-    .then(json => console.log(json));
+    console.log('Setting expectations');
+    fetch(`${stubServerBaseUrl ? stubServerBaseUrl : `http://localhost:9000/`}_specmatic/expectations`, {
+        method: 'POST',
+        body: JSON.stringify(stubResponse),
+    }).then(json => console.log(json));
 };
 
-export const setExpectations = loadDynamicStub;
-
-export const printSpecmaticJarVersion = () => {
-  execSh(
-    `java -jar ${specmaticJarPath} --version`
-    , {}, (err: any) => {
-      if (err) {
-        console.log('Exit code: ', err.code);
-        process.exit(err.code);
-      }
+const printJarVersion = () => {
+    execSh(`java -jar ${specmaticJarPath} --version`, {}, (err: any) => {
+        if (err) {
+            console.error('Could not print specmatic version', err);
+        }
     });
-}
+};
+
+export { startStub, stopStub, test, setExpectations, printJarVersion };