specmatic 1.0.0 → 1.0.3

package/src/core/__tests__/test.ts

@@ -0,0 +1,176 @@
+import path from 'path';
+import { ChildProcess, spawn } from 'child_process';
+import { mock as jestMock, mockReset } from 'jest-mock-extended';
+import { Readable } from 'stream';
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import fs from 'fs';
+import express from 'express';
+
+import * as specmatic from '../..';
+import { specmaticCoreJarName } from '../../config';
+
+jest.mock('child_process');
+
+const SPECMATIC_JAR_PATH = path.resolve(__dirname, '..', '..', '..', specmaticCoreJarName);
+const CONTRACT_FILE_PATH = './contracts';
+const HOST = 'localhost';
+const PORT = 8000;
+
+const javaProcessMock = jestMock<ChildProcess>();
+const readableMock = jestMock<Readable>();
+javaProcessMock.stdout = readableMock;
+javaProcessMock.stderr = readableMock;
+
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+
+test('runs the contract tests', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH)).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`);
+});
+
+test('takes additional pass through arguments', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH, ['P1', 'P2'])).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT} P1 P2`);
+});
+
+test('additional pass through arguments can be string or number', async () => {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH, ['P1', 123])).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT} P1 123`);
+});
+
+test('runs the contract tests with host and port optional', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test()).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`test --junitReportDir=dist/test-report`);
+});
+
+test('runs the contract tests with contracts path optional', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test(HOST, PORT)).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
+    expect(spawn.mock.calls[0][1][2]).toBe(`test --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`);
+});
+
+test('runs the contract tests and returns a summary', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test()).resolves.toStrictEqual({
+        total: 5,
+        success: 3,
+        failure: 2,
+    });
+});
+
+test('runs the contract tests and returns a summary with skipped tests count included', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFileWithName('sample-junit-result-skipped.xml');
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test()).resolves.toStrictEqual({
+        total: 3,
+        success: 2,
+        failure: 1,
+    });
+});
+
+test('runs the contract tests and get summary when there is just one test', async function () {
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFileWithName('sample-junit-result-single.xml');
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.test()).resolves.toStrictEqual({
+        total: 1,
+        success: 1,
+        failure: 0,
+    });
+});
+
+test('invocation makes sure previous junit report if any is deleted', async function () {
+    const spy = jest.spyOn(fs, 'rmSync');
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFileWithName('sample-junit-result-single.xml');
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await specmatic.test();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(path.resolve('dist/test-report'), { force: true, recursive: true });
+});
+
+test('passes an property indicating api endpoint based on host and port supplied when api coverage is enabled', async () => {
+    var app = express();
+    app.get('/', () => {});
+
+    spawn.mockReturnValue(javaProcessMock);
+    setTimeout(() => {
+        copyReportFile();
+        javaProcessMock.on.mock.calls[0][1]()
+    }, 0);
+
+    await expect(specmatic.testWithApiCoverage(app, HOST, PORT)).resolves.toBeTruthy();
+
+    expect(spawn.mock.calls[0][1][0]).toMatch(/endpointsAPI="http:\/\/.+?:[0-9]+?"/);
+});
+
+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/index.ts

@@ -0,0 +1,261 @@
+import axios from 'axios'
+import path from 'path'
+import { ChildProcess } from 'child_process'
+import { XMLParser } from 'fast-xml-parser'
+import fs from 'fs'
+import logger from '../common/logger'
+import { callCore } from '../common/runner'
+import listExpressEndpoints from 'express-list-endpoints'
+import http from 'http'
+import { AddressInfo } from 'net'
+import { gracefulShutdown } from './shutdownUtils'
+
+export class Stub {
+    host: string
+    port: number
+    url: string
+    process: ChildProcess
+    constructor(host: string, port: number, url: string, process: ChildProcess) {
+        this.host = host
+        this.port = port
+        this.url = url
+        this.process = process
+    }
+}
+
+const startStub = (host?: string, port?: number, args?: (string | number)[]): Promise<Stub> => {
+    var cmd = `stub`
+    if (host) cmd += ` --host=${host}`
+    if (port) cmd += ` --port=${port}`
+    if (args) cmd += ' ' + args.join(' ')
+
+    logger.info('Stub: Starting server')
+    logger.debug(`Stub: Executing "${cmd}"`)
+
+    return new Promise((resolve, reject) => {
+        const javaProcess = callCore(
+            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}`)
+                        const stubInfo = message.split('on')
+                        if (stubInfo.length < 2) reject('Cannot determine url from stub output')
+                        else {
+                            const url = stubInfo[1].trim()
+                            const urlInfo = /(.*?):\/\/(.*?):([0-9]+)/.exec(url)
+                            if ((urlInfo?.length ?? 0) < 4) reject('Cannot determine host and port from stub output')
+                            else resolve(new Stub(urlInfo![2], parseInt(urlInfo![3]), urlInfo![0], javaProcess))
+                        }
+                    } else if (message.indexOf('Address already in use') > -1) {
+                        logger.error(`Stub: ${message}`)
+                        reject('Address already in use')
+                    } else {
+                        logger.debug(`Stub: ${message}`)
+                    }
+                } else {
+                    logger.error(`Stub: ${message}`)
+                }
+            }
+        )
+    })
+}
+
+const stopStub = async (stub: Stub) => {
+    logger.debug(`Stub: Stopping server at ${stub.url}`)
+    const javaProcess = stub.process
+    javaProcess.stdout?.removeAllListeners()
+    javaProcess.stderr?.removeAllListeners()
+    javaProcess.removeAllListeners('close')
+    logger.debug('Trying to stop stub process gracefully ...')
+    await gracefulShutdown(javaProcess)
+    logger.debug('Completed graceful termination of the stub process')
+    logger.info(`Stub: Stopped server at ${stub.url}`)
+}
+
+const testWithApiCoverage = async (
+    expressApp: any,
+    host?: string,
+    port?: number,
+    contractPath?: string,
+    args?: (string | number)[]
+): Promise<{ [k: string]: number } | undefined> => {
+    return new Promise(async (resolve, _reject) => {
+        let apiCoverageServer = await startApiCoverageServer(expressApp)
+        const results = await test(host, port, contractPath, args)
+        apiCoverageServer.close(() => {
+            resolve(results)
+        })
+    })
+}
+
+const test = (host?: string, port?: number, contractPath?: string, args?: (string | number)[]): Promise<{ [k: string]: number } | undefined> => {
+    const specsPath = path.resolve(contractPath + '')
+
+    var cmd = `test`
+    if (contractPath) cmd += ` ${specsPath}`
+    cmd += ' --junitReportDir=dist/test-report'
+    if (host) cmd += ` --host=${host}`
+    if (port) cmd += ` --port=${port}`
+    if (args) cmd += ' ' + args.join(' ')
+
+    logger.info('Test: Running')
+    logger.debug(`Test: Executing "${cmd}"`)
+
+    const reportDir = path.resolve('dist/test-report')
+    fs.rmSync(reportDir, { recursive: true, force: true })
+
+    return new Promise((resolve, _reject) => {
+        callCore(
+            cmd,
+            (err: any) => {
+                if (err) logger.error(`Test: Failed with error ${err}`)
+                var testCases = parseJunitXML()
+                const total = testCases.length
+                const failure = testCases.filter((testcase: { [id: string]: any }) => testcase['failure'] || testcase['skipped']).length
+                const success = total - failure
+                var result = { total, success, failure }
+                resolve(result)
+            },
+            (message, error) => {
+                if (message.indexOf('API COVERAGE SUMMARY') > -1) {
+                    console.log(message) //Log always for all log levels
+                } else {
+                    logger[error ? 'error' : 'debug'](`Test: ${message}`)
+                }
+            }
+        )
+    })
+}
+
+const showTestResults = (testFn: (name: string, cb: () => void) => void) => {
+    var testCases = parseJunitXML()
+    testCases.map(function (testcase: { [id: string]: any }) {
+        var name = 'No Name'
+        if (testcase['system-out']) {
+            const nameTempArr = testcase['system-out']
+                .trim()
+                .replace(/\n/g, '')
+                .split(/display-name:.*Scenario: /)
+            if (nameTempArr.length > 1) name = nameTempArr[1].trim()
+        }
+        testFn(name, () => {
+            if (testcase.failure || testcase.skipped) throw new Error('Did not pass')
+        })
+    })
+}
+
+const setExpectations = (stubPath: string, stubServerBaseUrl?: string): Promise<void> => {
+    const stubResponse = require(path.resolve(stubPath))
+    stubServerBaseUrl = stubServerBaseUrl || 'http://localhost:9000'
+
+    logger.info(`Set Expectations: Stub url is ${stubServerBaseUrl}`)
+
+    return new Promise((resolve, reject) => {
+        axios
+            .post(`${stubServerBaseUrl}/_specmatic/expectations`, stubResponse)
+            .then(response => {
+                logger.debug(`Set Expectations: ${response.data}`)
+                logger.info('Set Expectations: Finished')
+                resolve()
+            })
+            .catch(err => {
+                logger.error(`Set Expectations: Failed with error ${err}`)
+                reject(`Setting expecation failed with error ${err}`)
+            })
+    })
+}
+
+const printJarVersion = () => {
+    const cmd = `--version`
+    logger.info('Print Jar Version: Running')
+    logger.debug(`Print Jar Version: Executing "${cmd}"`)
+
+    callCore(
+        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 startApiCoverageServer = (expressApp: any): Promise<http.Server> => {
+    logger.debug(`Registering API endpoint for coverage`)
+    let app = http.createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        const endPoints = JSON.stringify(extractEndPoints(expressApp))
+        logger.debug(`Endpoints: ${endPoints}`)
+        res.end(endPoints)
+    })
+    return new Promise<http.Server>((resolve, reject) => {
+        app.on('error', err => {
+            logger.error('Error while starting end points server for api coverage', err)
+            reject('Error while starting end points server for api coverage')
+        })
+        app.listen({ host: '127.0.0.1', port: 0 }, () => {
+            const address = app.address() as AddressInfo | null
+            process.env['endpointsAPI'] = `http://${address?.address}:${address?.port}`
+            logger.info(`Endpoints API registered at ${process.env['endpointsAPI']}`)
+            resolve(app)
+        })
+    })
+}
+
+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
+}
+
+const listEndPoints = (expressApp: any): { [key: string]: string[] } => {
+    const details = listExpressEndpoints(expressApp)
+    let endPoints: { [key: string]: string[] } = {}
+    details.map(apiDetail => {
+        endPoints[apiDetail.path] = apiDetail.methods
+    })
+    delete endPoints['*']
+    return endPoints
+}
+
+function extractEndPoints(expressApp: any) {
+    let endPoints = listEndPoints(expressApp)
+    let springActuatorPayload = {
+        contexts: {
+            application: {
+                mappings: {
+                    dispatcherServlets: {
+                        dispatcherServlet: [],
+                    },
+                },
+            },
+        },
+    }
+    Object.keys(endPoints)
+        .sort()
+        .map(path => {
+            springActuatorPayload.contexts.application.mappings.dispatcherServlets.dispatcherServlet.push({
+                details: {
+                    requestMappingConditions: {
+                        methods: endPoints[path].sort(),
+                        patterns: [path.replace(/:([^/]+)/g, '{$1}').replace(/\\/g, '')],
+                    },
+                },
+            } as never)
+        })
+    return springActuatorPayload
+}
+
+export { startStub, stopStub, test, testWithApiCoverage, setExpectations, printJarVersion, showTestResults }
+export { startApiCoverageServer }

package/src/core/shutdownUtils.ts

@@ -0,0 +1,21 @@
+import { ChildProcess } from 'child_process';
+import nodeProcess from 'node:process';
+import terminate from 'terminate/promise';
+import logger from '../common/logger'
+const kill = require('tree-kill');
+
+export const gracefulShutdown = async function (javaProcess: ChildProcess): Promise<void> {
+    return new Promise((resolve, reject) => {
+        logger.info('Sending SIGTERM to stop stub process')
+        kill(javaProcess.pid, 'SIGTERM', (err:Error) => {
+            if(err) {
+                logger.debug('Failed to send SIGTERM to stub process tree:', err);
+                resolve();
+            } else {
+                logger.debug('SIGTERM sent successfully to stub process tree');
+                resolve();
+            }
+        });
+    });
+}
+

package/src/downloadSpecmaticJar.js

@@ -0,0 +1,30 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json'); // Import the package.json file
+
+const specmaticVersion = packageJson.specmaticVersion;
+const jarUrl = `https://github.com/znsio/specmatic/releases/download/${specmaticVersion}/specmatic.jar`;
+const jarFilename = 'specmatic.jar'; // Specify the desired filename for the JAR
+
+const downloadPath = path.resolve(__dirname, '..', jarFilename);
+
+if (fs.existsSync(downloadPath)) {
+  console.log(`Deleting existing jar ...`);
+  fs.unlinkSync(downloadPath);
+}
+
+console.log("Downloading Specmatic jar version: " + specmaticVersion + " ...");
+axios({
+  method: 'get',
+  url: jarUrl,
+  responseType: 'stream',
+})
+  .then((response) => {
+    response.data.pipe(fs.createWriteStream(downloadPath));
+    console.log("Finished downloading Specmatic jar");
+  })
+  .catch((error) => {
+    console.error('Error downloading Specmatic Core JAR file version: ' + specmaticVersion, error);
+    process.exit(1);
+  });

package/src/index.ts

@@ -1,7 +1,24 @@
 export {
     startStub,
+    startStub as startHttpStub,
     stopStub,
+    stopStub as stopHttpStub,
     test,
+    testWithApiCoverage,
     setExpectations,
-    printJarVersion
-} from './lib';
+    setExpectations as setHttpStubExpectations,
+    printJarVersion,
+    showTestResults,
+} from './core'
+export {
+    startKafkaStub,
+    startKafkaStub as startKafkaMock,
+    stopKafkaStub,
+    stopKafkaStub as stopKafkaMock,
+    verifyKafkaStubMessage,
+    verifyKafkaStubMessage as verifyKafkaMockMessage,
+    verifyKafkaStub,
+    verifyKafkaStub as verifyKafkaMock,
+    setKafkaStubExpectations,
+    setKafkaStubExpectations as setKafkaMockExpectations,
+} from './kafka'

package/src/kafka/index.ts

@@ -0,0 +1,140 @@
+import { callKafka } from '../common/runner';
+import logger from '../common/logger';
+import { ChildProcess } from 'child_process';
+import axios from 'axios';
+import terminate from 'terminate/promise';
+
+export class KafkaStub {
+    port: number;
+    apiPort: number;
+    process: ChildProcess;
+    constructor(port: number, apiPort: number, process: ChildProcess) {
+        this.port = port;
+        this.apiPort = apiPort;
+        this.process = process;
+    }
+}
+
+const startKafkaStub = (port?: number, args?: (string | number)[]): Promise<KafkaStub> => {
+    var cmd = ``;
+    if (port) cmd += ` --port=${port}`;
+    if (args) cmd += ' ' + args.join(' ');
+
+    logger.info('Kafka Stub: Starting server');
+    logger.debug(`Kafka Stub: Executing "${cmd}"`);
+
+    return new Promise((resolve, reject) => {
+        let port: number, apiPort: number;
+        const javaProcess = callKafka(
+            cmd,
+            (err: any) => {
+                if (err) {
+                    logger.error(`Kafka Stub: Exited with error ${err}`);
+                }
+            },
+            (message, error) => {
+                if (!error) {
+                    if (message.indexOf('Kafka started on port') > -1) {
+                        logger.info(`Kafka Stub: ${message}`);
+                        const stubInfo = message.split('on port');
+                        if (stubInfo.length < 2) reject('Cannot determine port from kafka stub output');
+                        else port = parseInt(stubInfo[1].trim());
+                    } else if (message.indexOf('Starting api server on port') > -1) {
+                        logger.info(`Kafka Stub: ${message}`);
+                        const stubInfo = message.split(':');
+                        if (stubInfo.length < 2) reject('Cannot determine api port from kafka stub output');
+                        else apiPort = parseInt(stubInfo[1].trim());
+                    } else if (message.indexOf('Listening on topic') > -1) {
+                        logger.info(`Kafka Stub: ${message}`);
+                        if (port && apiPort) resolve(new KafkaStub(port, apiPort, javaProcess));
+                        else reject('No port or api port information available but kafka stub listening on topic already');
+                    } else if (message.indexOf('Address already in use') > -1) {
+                        logger.error(`Kafka Stub: ${message}`);
+                        reject('Address already in use');
+                    } else {
+                        logger.debug(`Kafka Stub: ${message}`);
+                    }
+                } else {
+                    logger.error(`Kafka Stub: ${message}`);
+                }
+            }
+        );
+    });
+};
+
+const stopKafkaStub = async (stub: KafkaStub) => {
+    logger.debug(`Kafka Stub: Stopping at port=${stub.port}, apiPort=${stub.apiPort}`);
+    const javaProcess = stub.process;
+    javaProcess.stdout?.removeAllListeners();
+    javaProcess.stderr?.removeAllListeners();
+    javaProcess.removeAllListeners('close');
+    await terminate(javaProcess.pid!);
+    logger.info(`Kafka Stub: Stopped at port=${stub.port}, apiPort=${stub.apiPort}`);
+};
+
+const setKafkaStubExpectations = (stub: KafkaStub, expecations: any): Promise<void> => {
+    const exectationsUrl = `http://localhost:${stub.apiPort}/_expectations`;
+    logger.info(`Kafka Set Expectations: Url is ${exectationsUrl}`);
+    return new Promise((resolve, reject) => {
+        axios
+            .post(`${exectationsUrl}`, expecations, {
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            })
+            .then(response => {
+                logger.debug(`Kafka Set Expectations: Finished ${JSON.stringify(response.data)}`)
+                resolve()
+            })
+            .catch(err => {
+                logger.error(`Kafka Set Expectations: Failed with error ${err}`)
+                reject(`Set expectation failed with error ${err}`)
+            })
+    });
+};
+
+const verifyKafkaStub = (stub: KafkaStub): Promise<Boolean> => {
+    const verificationUrl = `http://localhost:${stub.apiPort}/_expectations/verifications`;
+    logger.info(`Kafka Verification: Url is ${verificationUrl}`);
+    return new Promise((resolve, reject) => {
+        axios.post(`${verificationUrl}`, {
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        })
+            .then(response => {
+                    logger.debug(`Kafka Verification: Finished ${JSON.stringify(response.data)}`);
+                    if (!response.data.success) logger.info(`Kafka Verification: Errors\n${JSON.stringify(response.data)}`);
+                    resolve(response.data.success);
+            })
+            .catch(err => {
+                logger.error(`Kafka Verification: Failed with error ${err}`);
+                reject(`Kafka verification failed with error ${err}`);
+            });
+    });
+};
+
+const verifyKafkaStubMessage = (stub: KafkaStub, topic: string, value: string): Promise<Boolean> => {
+    const verificationUrl = `http://localhost:${stub.apiPort}/_verifications`;
+    logger.info(`Kafka Verify Message: Url is ${verificationUrl}`);
+    return new Promise((resolve, reject) => {
+        axios.post(`${verificationUrl}`, { topic: topic, value: value }, {
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        })
+            .then(response => {
+                logger.debug(`Kafka Verify Message: Finished ${JSON.stringify(response.data)}`);
+                resolve(response.data.received);
+            })
+            .catch(err => {
+                logger.error(`Kafka Verify Message: Failed with error ${err}`);
+                reject(`Kafka message verification failed with error ${err}`);
+            });
+    });
+};
+
+export { startKafkaStub, stopKafkaStub, verifyKafkaStubMessage, verifyKafkaStub, setKafkaStubExpectations };