specmatic 1.0.0 → 1.0.3

package/src/common/__tests__/logger.ts

@@ -0,0 +1,85 @@
+import { initLogger } from '../logger'
+import { when } from 'jest-when'
+
+import fs from 'fs'
+
+beforeEach(() => {
+    jest.resetAllMocks()
+    delete process.env.SPECMATIC_LOG_LEVEL
+})
+
+test('logging level is debug as configured in package.json', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {"logLevel": "debug"}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('debug')
+})
+
+test('logging level is info as configured in package.json', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {"logLevel": "info"}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('info')
+})
+
+test('defaults logging level to warn when logLevel setting does not exist with specmatic configuration', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('warn')
+})
+
+test('defaults logging level to warn when specmatic configuration does not exist', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{}')
+    const logger = initLogger()
+    expect(logger.level).toBe('warn')
+})
+
+test('defaults logging level to warn when package.json does not exist', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy)
+        .calledWith('./package.json')
+        .mockImplementation(() => {
+            throw new Error()
+        })
+    const logger = initLogger()
+    expect(logger.level).toBe('warn')
+})
+
+test('log level is read from environment variable', () => {
+    process.env.SPECMATIC_LOG_LEVEL = 'debug'
+    const logger = initLogger()
+    expect(logger.level).toBe('debug')
+})
+
+test('log level set in environment variable takes precendece over specmatic.json', () => {
+    process.env.SPECMATIC_LOG_LEVEL = 'error'
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {"logLevel": "debug"}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('error')
+})
+
+test('log level set in environment variable is used instead of default', () => {
+    process.env.SPECMATIC_LOG_LEVEL = 'error'
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{}')
+    const logger = initLogger()
+    expect(logger.level).toBe('error')
+})
+
+test('uses default log level "warn" when log level configured in specmatic.json is invalid', () => {
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {"logLevel": "silly"}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('warn')
+})
+
+test('ignores log level configured in environment variable when invalid', () => {
+    process.env.SPECMATIC_LOG_LEVEL = 'silly'
+    const packageJsonFileReadSpy = jest.spyOn(fs, 'readFileSync')
+    when(packageJsonFileReadSpy).calledWith('./package.json').mockReturnValue('{"specmatic": {"logLevel": "debug"}}')
+    const logger = initLogger()
+    expect(logger.level).toBe('debug')
+})

package/src/common/logger.ts

@@ -0,0 +1,49 @@
+import { config, createLogger, format, transports } from 'winston'
+import fs from 'fs'
+
+const logFormat = format.printf(({ level, message, label, timestamp }) => {
+    return `[${label}] ${timestamp} ${level}: ${message}`
+})
+
+function getSpecmaticConfig() {
+    const packageJsonPath = './package.json'
+    var specmaticConfig
+    if (fs.existsSync(packageJsonPath)) {
+        let packageJsonContent
+        try {
+            packageJsonContent = fs.readFileSync(packageJsonPath)
+        } catch (error) {
+            packageJsonContent = '{}'
+        }
+        const packageConfig = JSON.parse(packageJsonContent as unknown as string)
+        specmaticConfig = packageConfig.specmatic
+    }
+    return specmaticConfig || {}
+}
+
+function getLogLevel() {
+    let logLevel
+    if (process.env.SPECMATIC_LOG_LEVEL) {
+        logLevel = process.env.SPECMATIC_LOG_LEVEL
+    }
+    if (!logLevel || !config.syslog.levels[logLevel]) {
+        const specmaticConfig = getSpecmaticConfig()
+        logLevel = specmaticConfig.logLevel
+    }
+    if (!logLevel || !config.syslog.levels[logLevel]) {
+        logLevel = 'warn'
+    }
+    return logLevel
+}
+
+export function initLogger() {
+    let logLevel = getLogLevel()
+    const logger = createLogger({
+        level: logLevel,
+        format: format.combine(format.label({ label: 'specmatic' }), format.timestamp({ format: 'DD-MM-YYYY HH:mm:ss' }), logFormat),
+        transports: [new transports.Console()],
+    })
+    return logger
+}
+
+export default initLogger()

package/src/common/runner.ts

@@ -0,0 +1,44 @@
+import execSh from 'exec-sh';
+import path from 'path';
+import { specmaticCoreJarName, specmaticKafkaJarName } from '../config';
+import logger from '../common/logger';
+import { ChildProcess, spawn, SpawnOptions } from 'child_process';
+
+const callCore = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
+    const rootPath = path.resolve(__dirname, '..', '..');
+    const specmaticJarPath = path.resolve(rootPath, specmaticCoreJarName);
+    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
+    return callJar(specmaticJarPath, args, done, onOutput);
+};
+
+const callKafka = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
+    const rootPath = path.resolve(__dirname, '..', '..', '..', 'specmatic-beta', 'kafka');
+    const specmaticJarPath = path.resolve(rootPath, specmaticKafkaJarName);
+    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
+    return callJar(specmaticJarPath, args, done, onOutput);
+};
+
+function callJar(jarPath: string, args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void) {
+    let argsList = [];
+    if (process.env['endpointsAPI']) {
+        argsList.push(`-DendpointsAPI="${process.env['endpointsAPI']}"`);
+    }
+    argsList = argsList.concat(['-jar', `"${jarPath}"`, args]);
+    const javaProcess: ChildProcess = spawn('java', argsList, { stdio: 'pipe', stderr: 'pipe', shell: true } as SpawnOptions);
+    javaProcess.stdout?.on('data', function (data: String) {
+        onOutput(`${data}`, false);
+    });
+    javaProcess.stderr?.on('data', function (data: String) {
+        onOutput(`${data}`, true);
+    });
+    javaProcess.on('close', function (code:number) {
+        if (code) {
+            done(new Error('Command exited with non zero code: ' + code))
+        } else {
+            done(null);
+        }
+    });
+    return javaProcess;
+}
+
+export { callCore, callKafka };

package/src/config.ts

@@ -1,3 +1,2 @@
-export const specmaticJarPathLocal = './node_modules/specmatic/specmatic.jar';
-export const specmaticJarPathRemote = 'https://github.com/znsio/specmatic/releases/download/0.24.2/specmatic.jar';
-export const specmatic = 'specmatic.json'
+export const specmaticCoreJarName = 'specmatic.jar';
+export const specmaticKafkaJarName = 'specmatic-kafka-all.jar';

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

@@ -0,0 +1,103 @@
+import * as specmatic from '..'
+import express from 'express'
+import request from 'supertest'
+
+let server
+var app
+
+beforeEach(async () => {
+    app = express()
+    server = await specmatic.startApiCoverageServer(app)
+})
+
+afterEach(done => {
+    server.close(() => {
+        done()
+    })
+})
+
+test('adds an environment variable indicating api endpoits route is configured', async () => {
+    app.get('/', () => {})
+    expect(process.env.endpointsAPI).toMatch(/http:\/\/.+?:[0-9]+?/)
+})
+
+test('gives list of end points for a single route defined on express app', async () => {
+    app.get('/', () => {})
+    const res = await request(server).get('/').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 () => {
+    app.get('/', () => {})
+    app.post('/', () => {})
+    app.get('/ping', () => {})
+    const res = await request(server).get('/').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 () => {
+    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)
+
+    const res = await request(server).get('/').accept('application/json').expect(200)
+    const response = generateResponseObject({ '/product': ['GET', 'POST'], '/user': ['DELETE', 'GET', 'POST', 'PUT'] })
+    expect(res.body).toStrictEqual(response)
+})
+
+test('coverts express route variable syntax to spring request mapping syntax', async () => {
+    app.get('/:id', () => {})
+    const res = await request(server).get('/').accept('application/json').expect(200)
+    const response = generateResponseObject({ '/{id}': ['GET'] })
+    expect(res.body).toStrictEqual(response)
+})
+
+test('coverts express route multiple variable syntax to spring request mapping syntax', async () => {
+    app.get('/:store/:id', () => {})
+    const res = await request(server).get('/').accept('application/json').expect(200)
+    const response = generateResponseObject({ '/{store}/{id}': ['GET'] })
+    expect(res.body).toStrictEqual(response)
+})
+
+test('removes escaped dot and backslash in url', async () => {
+    app.get('/v1\\.0/:store/:id', () => {})
+    const res = await request(server).get('/').accept('application/json').expect(200)
+    const response = generateResponseObject({ '/v1.0/{store}/{id}': ['GET'] })
+    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__/print.jar.version.ts

@@ -0,0 +1,28 @@
+import path from 'path';
+import { ChildProcess, spawn } from 'child_process';
+import { mock as jestMock, mockReset } from 'jest-mock-extended';
+import { Readable } from 'stream';
+import * as specmatic from '../..';
+import { specmaticCoreJarName } from '../../config';
+
+jest.mock('child_process');
+
+const SPECMATIC_JAR_PATH = path.resolve(__dirname, '..', '..', '..', specmaticCoreJarName);
+
+const javaProcessMock = jestMock<ChildProcess>();
+const readableMock = jestMock<Readable>();
+javaProcessMock.stdout = readableMock;
+javaProcessMock.stderr = readableMock;
+
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+
+test('prints bundled jar version', () => {
+    spawn.mockReturnValue(javaProcessMock);
+
+    specmatic.printJarVersion();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe('--version');
+});

package/src/core/__tests__/set.expectation.ts

@@ -0,0 +1,54 @@
+import axios from 'axios';
+import path from 'path';
+import * as specmatic from '../..';
+import mockStub from '../../../test-resources/sample-mock-stub.json';
+import { mockReset } from 'jest-mock-extended';
+
+jest.mock('axios');
+
+const STUB_PATH = 'test-resources/sample-mock-stub.json';
+
+beforeEach(() => {
+    mockReset(axios);
+});
+
+test('setExpectations with default baseUrl', async () => {
+    axios.post.mockResolvedValue({ status: 200 });
+    await expect(specmatic.setExpectations(path.resolve(STUB_PATH))).toResolve();
+
+    expect(axios.post).toHaveBeenCalledTimes(1);
+    expect(axios.post.mock.calls[0][0]).toBe('http://localhost:9000/_specmatic/expectations');
+    expect(axios.post.mock.calls[0][1]).toMatchObject(mockStub);
+});
+
+test('setExpectations with a different baseUrl for the stub server', async () => {
+    axios.post.mockResolvedValue({ status: 200 });
+    const stubServerBaseUrl = 'http://localhost:8000';
+
+    await expect(specmatic.setExpectations(path.resolve(STUB_PATH), stubServerBaseUrl)).toResolve();
+
+    expect(axios.post).toHaveBeenCalledTimes(1);
+    expect(axios.post.mock.calls[0][0]).toBe(`${stubServerBaseUrl}/_specmatic/expectations`);
+    expect(axios.post.mock.calls[0][1]).toMatchObject(mockStub);
+});
+
+test('setExpectations notifies when it fails', async () => {
+    axios.post.mockReturnValue(Promise.reject());
+
+    await expect(specmatic.setExpectations(path.resolve(STUB_PATH))).toReject();
+
+    expect(axios.post).toHaveBeenCalledTimes(1);
+    expect(axios.post.mock.calls[0][0]).toBe('http://localhost:9000/_specmatic/expectations');
+    expect(axios.post.mock.calls[0][1]).toMatchObject(mockStub);
+});
+
+test('setExpectations notifies as failure when status code is not 200', async () => {
+    axios.post.mockReturnValue(Promise.reject('Cannot set expectations'));
+    const stubServerBaseUrl = 'http://localhost:8000';
+
+    await expect(specmatic.setExpectations(path.resolve(STUB_PATH), stubServerBaseUrl)).toReject();
+
+    expect(axios.post).toHaveBeenCalledTimes(1);
+    expect(axios.post.mock.calls[0][0]).toBe(`${stubServerBaseUrl}/_specmatic/expectations`);
+    expect(axios.post.mock.calls[0][1]).toMatchObject(mockStub);
+});

package/src/core/__tests__/set.test.results.ts

@@ -0,0 +1,62 @@
+import path from 'path';
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import * as specmatic from '../..';
+
+test('invokes the test function', () => {
+    const cb = jest.fn();
+    copyReportFile();
+    specmatic.showTestResults(cb);
+    expect(cb).toHaveBeenCalledTimes(5);
+    expect(() => cb.mock.calls[0][1]()).not.toThrow();
+    expect(() => cb.mock.calls[1][1]()).not.toThrow();
+    expect(() => cb.mock.calls[2][1]()).not.toThrow();
+    expect(() => cb.mock.calls[3][1]()).toThrow();
+    expect(() => cb.mock.calls[4][1]()).toThrow();
+});
+
+test('works with junit report from generative tests mode', () => {
+    const cb = jest.fn();
+    copyReportFileWithName('sample-junit-result-generative.xml');
+    specmatic.showTestResults(cb);
+    expect(cb).toHaveBeenCalledTimes(4);
+});
+
+test('shows "No Name" when test name cannot be found within system-out tag', () => {
+    const cb = jest.fn();
+    copyReportFileWithName('sample-junit-result-no-testname.xml');
+    specmatic.showTestResults(cb);
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(cb).toHaveBeenCalledWith('No Name', expect.any(Function));
+});
+
+test('shows "No Name" where system-out tag does not exist', () => {
+    const cb = jest.fn();
+    copyReportFileWithName('sample-junit-result-corrupt.xml');
+    specmatic.showTestResults(cb);
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(cb).toHaveBeenCalledWith('No Name', expect.any(Function));
+});
+
+test('handles report having skipped tests', () => {
+    const cb = jest.fn();
+    copyReportFileWithName('sample-junit-result-skipped.xml');
+    specmatic.showTestResults(cb);
+    expect(cb).toHaveBeenCalledTimes(3);
+    expect(() => cb.mock.calls[0][1]()).toThrow();
+    expect(() => cb.mock.calls[1][1]()).not.toThrow();
+    expect(() => cb.mock.calls[2][1]()).not.toThrow();
+});
+
+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/core/__tests__/stub.ts

@@ -0,0 +1,136 @@
+import path from 'path';
+import { ChildProcess, spawn } from 'child_process';
+import { mock as jestMock, mockReset } from 'jest-mock-extended';
+import { Readable } from 'stream';
+import terminate from 'terminate/promise';
+
+import * as specmatic from '../..';
+import { specmaticCoreJarName } from '../../config';
+import { Stub } from '..';
+import * as shutDown from '../shutdownUtils'
+
+
+jest.mock('child_process');
+jest.mock('terminate');
+jest.mock('../shutdownUtils')
+
+const SPECMATIC_JAR_PATH = path.resolve(__dirname, '..', '..', '..', specmaticCoreJarName);
+const HOST = 'localhost';
+const PORT = 8000;
+
+const javaProcessMock = jestMock<ChildProcess>();
+const readableMock = jestMock<Readable>();
+javaProcessMock.stdout = readableMock;
+javaProcessMock.stderr = readableMock;
+
+const stubUrl = `http://${HOST}:${PORT}`;
+const stub = new Stub(HOST, PORT, stubUrl, javaProcessMock);
+
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+
+test('starts the specmatic stub server', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT)).resolves.toStrictEqual(stub);
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('notifies when start fails due to port not available', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1]('Address already in use'), 0);
+
+    await expect(specmatic.startStub(HOST, PORT)).toReject();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('returns host, port and stub url', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    const randomPort = 62269;
+    const stubUrl = `http://${HOST}:${randomPort}`;
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}. Ctrl + C to stop.`), 0);
+
+    const stub = new Stub(HOST, randomPort, stubUrl, javaProcessMock);
+
+    await expect(specmatic.startStub(HOST, PORT)).resolves.toStrictEqual(stub);
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('fails if stub url is not available in start up message', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT)).toReject();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('fails if host info is not available in start up message', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    const stubUrl = `http://`;
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT)).toReject();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('fails if port info is not available in start up message', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    const stubUrl = `http://${HOST}`;
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT)).toReject();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+});
+
+test('host and port are optional', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub()).resolves.toStrictEqual(stub);
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe('stub');
+});
+
+test('takes additional pass through arguments', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT, ['p1', 'p2'])).resolves.toStrictEqual(stub);
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT} p1 p2`);
+});
+
+test('additional pass through arguments can be string or number', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => readableMock.on.mock.calls[0][1](`Stub server is running on ${stubUrl}`), 0);
+
+    await expect(specmatic.startStub(HOST, PORT, ['p1', 123])).resolves.toStrictEqual(stub);
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT} p1 123`);
+});
+
+test('stopStub method stops any running stub server', async () => {
+    shutDown.gracefulShutdown.mockResolvedValue(true);
+    specmatic.stopStub(stub);
+
+    expect(readableMock.removeAllListeners).toHaveBeenCalledTimes(2);
+    expect(javaProcessMock.removeAllListeners).toHaveBeenCalledTimes(1);
+    expect(shutDown.gracefulShutdown).toHaveBeenCalledTimes(1);
+});