@pact-foundation/pact 16.3.1 → 16.4.0

package/src/pact.integration.spec.js

@@ -32,90 +32,92 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* tslint:disable:no-unused-expression no-empty */
-var chai = __importStar(require("chai"));
-var chai_as_promised_1 = __importDefault(require("chai-as-promised"));
-var sinon_chai_1 = __importDefault(require("sinon-chai"));
-var axios_1 = __importDefault(require("axios"));
-var fs = require("fs");
-var net = require("net");
-var path = require("path");
-// eslint-disable-next-line import/first
-var v4_1 = require("./v4");
-var v3_1 = require("./v3");
-var expect = chai.expect;
+const chai = __importStar(require("chai"));
+const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
+const sinon_chai_1 = __importDefault(require("sinon-chai"));
+const axios_1 = __importDefault(require("axios"));
+const fs = require("node:fs");
+const net = require("node:net");
+const path = require("node:path");
+const v4_1 = require("./v4");
+const v3_1 = require("./v3");
+const { expect } = chai;
 chai.use(sinon_chai_1.default);
 chai.use(chai_as_promised_1.default);
-describe('V4 Pact', function () {
-    var pact;
-    var pactFilePath = path.resolve(process.cwd(), 'pacts', 'v4consumer-v4provider.json');
-    var interactionByDescription = function (description) {
-        var pactJson = JSON.parse(fs.readFileSync(pactFilePath, 'utf8'));
-        var matches = pactJson.interactions.filter(function (item) { return item.description === description; });
-        expect(matches, "expected exactly one interaction for \"".concat(description, "\"")).to.have.lengthOf(1);
-        var interaction = matches[0];
+describe('V4 Pact', () => {
+    let pact;
+    const pactFilePath = path.resolve(process.cwd(), 'pacts', 'v4consumer-v4provider.json');
+    const interactionByDescription = (description) => {
+        const pactJson = JSON.parse(fs.readFileSync(pactFilePath, 'utf8'));
+        const matches = pactJson.interactions.filter((item) => item.description === description);
+        expect(matches, `expected exactly one interaction for "${description}"`).to.have.lengthOf(1);
+        const [interaction] = matches;
         return interaction;
     };
-    var expectCommentsToContain = function (interaction, reason, textComment, testName) {
-        var comments = interaction.comments;
+    const expectCommentsToContain = (interaction, reason, textComment, testName) => {
+        const comments = interaction.comments;
         expect(comments.reason).to.equal(reason);
         expect(comments.text).to.include(textComment);
         expect(comments.testname).to.equal(testName);
     };
-    beforeEach(function () {
+    const expectReferenceToEqual = (interaction, group, name, value) => {
+        const comments = interaction.comments;
+        const references = comments.references;
+        expect(references[group][name]).to.equal(value);
+    };
+    beforeEach(() => {
         pact = new v4_1.PactV4({
             consumer: 'v4consumer',
             provider: 'v4provider',
         });
     });
-    describe('HTTP req/res contract', function () {
-        it('generates a pact', function () {
-            return pact
+    describe('HTTP req/res contract', () => {
+        it('generates a pact', () => pact
+            .addInteraction()
+            .given('some state')
+            .given('a second state')
+            .uponReceiving('a standard HTTP req/res')
+            .withRequest('POST', '/', (builder) => {
+            builder
+                .jsonBody({
+                foo: 'bar',
+            })
+                .headers({
+                'x-foo': 'x-bar',
+            });
+        })
+            .willRespondWith(200, (builder) => {
+            builder
+                .jsonBody({
+                foo: 'bar',
+            })
+                .headers({
+                'x-foo': 'x-bar',
+            });
+        })
+            .executeTest(async (server) => axios_1.default.post(server.url, {
+            foo: 'bar',
+        }, {
+            headers: {
+                'x-foo': 'x-bar',
+            },
+        })));
+        it('generates a pact with interaction metadata', async () => {
+            const description = 'v4 metadata http req/res interaction';
+            await pact
                 .addInteraction()
                 .given('some state')
                 .given('a second state')
-                .uponReceiving('a standard HTTP req/res')
-                .withRequest('POST', '/', function (builder) {
+                .uponReceiving(description)
+                .pending()
+                .comment({ key: 'reason', value: 'covered by HTTP metadata test' })
+                .comment('second note from HTTP metadata test')
+                .testName('http metadata test name')
+                .withRequest('POST', '/', (builder) => {
                 builder
                     .jsonBody({
                     foo: 'bar',
@@ -124,7 +126,7 @@ describe('V4 Pact', function () {
                     'x-foo': 'x-bar',
                 });
             })
-                .willRespondWith(200, function (builder) {
+                .willRespondWith(200, (builder) => {
                 builder
                     .jsonBody({
                     foo: 'bar',
@@ -133,264 +135,200 @@ describe('V4 Pact', function () {
                     'x-foo': 'x-bar',
                 });
             })
-                .executeTest(function (server) { return __awaiter(void 0, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, axios_1.default.post(server.url, {
-                            foo: 'bar',
-                        }, {
-                            headers: {
-                                'x-foo': 'x-bar',
-                            },
-                        })];
-                });
-            }); });
+                .executeTest(async (server) => axios_1.default.post(server.url, {
+                foo: 'bar',
+            }, {
+                headers: {
+                    'x-foo': 'x-bar',
+                },
+            }));
+            const interaction = interactionByDescription(description);
+            expect(interaction.pending).to.equal(true);
+            expectCommentsToContain(interaction, 'covered by HTTP metadata test', 'second note from HTTP metadata test', 'http metadata test name');
         });
-        it('generates a pact with interaction metadata', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var description, interaction;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        description = 'v4 metadata http req/res interaction';
-                        return [4 /*yield*/, pact
-                                .addInteraction()
-                                .given('some state')
-                                .given('a second state')
-                                .uponReceiving(description)
-                                .pending()
-                                .comment({ key: 'reason', value: 'covered by HTTP metadata test' })
-                                .comment('second note from HTTP metadata test')
-                                .testName('http metadata test name')
-                                .withRequest('POST', '/', function (builder) {
-                                builder
-                                    .jsonBody({
-                                    foo: 'bar',
-                                })
-                                    .headers({
-                                    'x-foo': 'x-bar',
-                                });
-                            })
-                                .willRespondWith(200, function (builder) {
-                                builder
-                                    .jsonBody({
-                                    foo: 'bar',
-                                })
-                                    .headers({
-                                    'x-foo': 'x-bar',
-                                });
-                            })
-                                .executeTest(function (server) { return __awaiter(void 0, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    return [2 /*return*/, axios_1.default.post(server.url, {
-                                            foo: 'bar',
-                                        }, {
-                                            headers: {
-                                                'x-foo': 'x-bar',
-                                            },
-                                        })];
-                                });
-                            }); })];
-                    case 1:
-                        _a.sent();
-                        interaction = interactionByDescription(description);
-                        expect(interaction.pending).to.equal(true);
-                        expectCommentsToContain(interaction, 'covered by HTTP metadata test', 'second note from HTTP metadata test', 'http metadata test name');
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it('supports regex matcher for response content-type with optional charset', function () {
-            return pact
+        it('records interaction references in the pact file', async () => {
+            const description = 'v4 http interaction with references';
+            await pact
                 .addInteraction()
-                .uponReceiving('a response with regex content-type header matcher')
+                .uponReceiving(description)
+                .reference('Jira', 'TICKET-123', 'https://jira.example.com/TICKET-123')
                 .withRequest('GET', '/')
-                .willRespondWith(200, function (builder) {
-                builder
-                    .headers({
-                    'Content-Type': v3_1.MatchersV3.regex(/^application\/json(;\s?charset=[\w-]+)?$/i, 'application/json'),
-                })
-                    .jsonBody({
-                    foo: 'bar',
-                });
+                .willRespondWith(200)
+                .executeTest(async (server) => axios_1.default.get(server.url));
+            const interaction = interactionByDescription(description);
+            expectReferenceToEqual(interaction, 'Jira', 'TICKET-123', 'https://jira.example.com/TICKET-123');
+        });
+        it('supports regex matcher for response content-type with optional charset', () => pact
+            .addInteraction()
+            .uponReceiving('a response with regex content-type header matcher')
+            .withRequest('GET', '/')
+            .willRespondWith(200, (builder) => {
+            builder
+                .headers({
+                'Content-Type': v3_1.MatchersV3.regex(/^application\/json(;\s?charset=[\w-]+)?$/i, 'application/json'),
             })
-                .executeTest(function (server) { return __awaiter(void 0, void 0, void 0, function () {
-                var response;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, axios_1.default.get(server.url)];
-                        case 1:
-                            response = _a.sent();
-                            expect(response.data).to.deep.equal({ foo: 'bar' });
-                            return [2 /*return*/];
-                    }
+                .jsonBody({
+                foo: 'bar',
+            });
+        })
+            .executeTest(async (server) => {
+            const response = await axios_1.default.get(server.url);
+            expect(response.data).to.deep.equal({ foo: 'bar' });
+        }));
+        it('supports regex matcher for request content-type with optional charset', () => pact
+            .addInteraction()
+            .uponReceiving('a request with regex content-type header matcher')
+            .withRequest('POST', '/', (builder) => {
+            builder
+                .headers({
+                'Content-Type': v3_1.MatchersV3.regex(/^application\/json(;\s?charset=[\w-]+)?$/i, 'application/json'),
+            })
+                .jsonBody({
+                foo: 'bar',
+            });
+        })
+            .willRespondWith(200, (builder) => {
+            builder.jsonBody({
+                ok: true,
+            });
+        })
+            .executeTest((server) => axios_1.default.post(server.url, {
+            foo: 'bar',
+        })));
+    });
+    describe('Asynchronous message contract', () => {
+        it('generates a pact with interaction metadata', async () => {
+            const description = 'v4 metadata async interaction message';
+            await pact
+                .addAsynchronousInteraction()
+                .given('an async message state')
+                .pending()
+                .comment({ key: 'reason', value: 'covered by async metadata test' })
+                .comment('second note from async metadata test')
+                .testName('async metadata test name')
+                .expectsToReceive(description, (builder) => {
+                builder.withJSONContent({
+                    event: 'user.created',
                 });
-            }); });
+            })
+                .executeTest(async () => Promise.resolve());
+            const interaction = interactionByDescription(description);
+            expect(interaction.pending).to.equal(true);
+            expectCommentsToContain(interaction, 'covered by async metadata test', 'second note from async metadata test', 'async metadata test name');
         });
-        it('supports regex matcher for request content-type with optional charset', function () {
-            return pact
-                .addInteraction()
-                .uponReceiving('a request with regex content-type header matcher')
-                .withRequest('POST', '/', function (builder) {
-                builder
-                    .headers({
-                    'Content-Type': v3_1.MatchersV3.regex(/^application\/json(;\s?charset=[\w-]+)?$/i, 'application/json'),
-                })
-                    .jsonBody({
-                    foo: 'bar',
-                });
+        it('records interaction references in the pact file', async () => {
+            const description = 'v4 async interaction with references';
+            await pact
+                .addAsynchronousInteraction()
+                .reference('GitHub', 'PR-456', 'https://github.com/example/repo/pull/456')
+                .expectsToReceive(description, (builder) => {
+                builder.withJSONContent({ event: 'user.created' });
             })
-                .willRespondWith(200, function (builder) {
-                builder.jsonBody({
-                    ok: true,
+                .executeTest(async () => Promise.resolve());
+            const interaction = interactionByDescription(description);
+            expectReferenceToEqual(interaction, 'GitHub', 'PR-456', 'https://github.com/example/repo/pull/456');
+        });
+    });
+    describe('Synchronous message contract', () => {
+        it('generates a pact with interaction metadata', async () => {
+            const description = 'v4 metadata sync interaction message';
+            await pact
+                .addSynchronousInteraction(description)
+                .given('a synchronous message state')
+                .pending()
+                .comment({ key: 'reason', value: 'covered by sync metadata test' })
+                .comment('second note from sync metadata test')
+                .testName('sync metadata test name')
+                .withRequest((builder) => {
+                builder.withJSONContent({
+                    request: 'ping',
                 });
             })
-                .executeTest(function (server) {
-                return axios_1.default.post(server.url, {
-                    foo: 'bar',
+                .withResponse((builder) => {
+                builder.withJSONContent({
+                    response: 'pong',
                 });
-            });
+            })
+                .executeTest(async () => Promise.resolve());
+            const interaction = interactionByDescription(description);
+            expect(interaction.pending).to.equal(true);
+            expectCommentsToContain(interaction, 'covered by sync metadata test', 'second note from sync metadata test', 'sync metadata test name');
+        });
+        it('records interaction references in the pact file', async () => {
+            const description = 'v4 sync interaction with references';
+            await pact
+                .addSynchronousInteraction(description)
+                .reference('Jira', 'TICKET-789', 'https://jira.example.com/TICKET-789')
+                .withRequest((builder) => {
+                builder.withJSONContent({ request: 'ping' });
+            })
+                .withResponse((builder) => {
+                builder.withJSONContent({ response: 'pong' });
+            })
+                .executeTest(async () => Promise.resolve());
+            const interaction = interactionByDescription(description);
+            expectReferenceToEqual(interaction, 'Jira', 'TICKET-789', 'https://jira.example.com/TICKET-789');
         });
     });
-    describe('Asynchronous message contract', function () {
-        it('generates a pact with interaction metadata', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var description, interaction;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        description = 'v4 metadata async interaction message';
-                        return [4 /*yield*/, pact
-                                .addAsynchronousInteraction()
-                                .given('an async message state')
-                                .pending()
-                                .comment({ key: 'reason', value: 'covered by async metadata test' })
-                                .comment('second note from async metadata test')
-                                .testName('async metadata test name')
-                                .expectsToReceive(description, function (builder) {
-                                builder.withJSONContent({
-                                    event: 'user.created',
-                                });
-                            })
-                                .executeTest(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                                return [2 /*return*/, Promise.resolve()];
-                            }); }); })];
-                    case 1:
-                        _a.sent();
-                        interaction = interactionByDescription(description);
-                        expect(interaction.pending).to.equal(true);
-                        expectCommentsToContain(interaction, 'covered by async metadata test', 'second note from async metadata test', 'async metadata test name');
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('Synchronous message contract', function () {
-        it('generates a pact with interaction metadata', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var description, interaction;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        description = 'v4 metadata sync interaction message';
-                        return [4 /*yield*/, pact
-                                .addSynchronousInteraction(description)
-                                .given('a synchronous message state')
-                                .pending()
-                                .comment({ key: 'reason', value: 'covered by sync metadata test' })
-                                .comment('second note from sync metadata test')
-                                .testName('sync metadata test name')
-                                .withRequest(function (builder) {
-                                builder.withJSONContent({
-                                    request: 'ping',
-                                });
-                            })
-                                .withResponse(function (builder) {
-                                builder.withJSONContent({
-                                    response: 'pong',
-                                });
-                            })
-                                .executeTest(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                                return [2 /*return*/, Promise.resolve()];
-                            }); }); })];
-                    case 1:
-                        _a.sent();
-                        interaction = interactionByDescription(description);
-                        expect(interaction.pending).to.equal(true);
-                        expectCommentsToContain(interaction, 'covered by sync metadata test', 'second note from sync metadata test', 'sync metadata test name');
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe('Plugin test', function () {
-        describe('Using the MATT plugin', function () {
-            var parseMattMessage = function (raw) {
-                return raw.replace(/(MATT)+/g, '').trim();
-            };
-            var generateMattMessage = function (raw) { return "MATT".concat(raw, "MATT"); };
-            describe('HTTP interface', function () {
-                it('generates a pact', function () { return __awaiter(void 0, void 0, void 0, function () {
-                    var mattRequest, mattResponse;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                mattRequest = "{\"request\": {\"body\": \"hello\"}}";
-                                mattResponse = "{\"response\":{\"body\":\"world\"}}";
-                                return [4 /*yield*/, pact
-                                        .addInteraction()
-                                        .given('the Matt protocol exists')
-                                        .uponReceiving('an HTTP request to /matt')
-                                        .usingPlugin({
-                                        plugin: 'matt',
-                                        version: '0.1.1',
-                                    })
-                                        .withRequest('POST', '/matt', function (builder) {
-                                        builder.pluginContents('application/matt', mattRequest);
-                                    })
-                                        .willRespondWith(200, function (builder) {
-                                        builder.pluginContents('application/matt', mattResponse);
-                                    })
-                                        .executeTest(function (mockserver) {
-                                        return axios_1.default
-                                            .request({
-                                            baseURL: mockserver.url,
-                                            headers: {
-                                                'content-type': 'application/matt',
-                                                Accept: 'application/matt',
-                                            },
-                                            data: generateMattMessage('hello'),
-                                            method: 'POST',
-                                            url: '/matt',
-                                        })
-                                            .then(function (res) {
-                                            expect(parseMattMessage(res.data)).to.eq('world');
-                                        });
-                                    })];
-                            case 1:
-                                _a.sent();
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
+    describe('Plugin test', () => {
+        describe('Using the MATT plugin', () => {
+            const parseMattMessage = (raw) => raw.replace(/(MATT)+/g, '').trim();
+            const generateMattMessage = (raw) => `MATT${raw}MATT`;
+            describe('HTTP interface', () => {
+                it('generates a pact', async () => {
+                    const mattRequest = `{"request": {"body": "hello"}}`;
+                    const mattResponse = `{"response":{"body":"world"}}`;
+                    await pact
+                        .addInteraction()
+                        .given('the Matt protocol exists')
+                        .uponReceiving('an HTTP request to /matt')
+                        .usingPlugin({
+                        plugin: 'matt',
+                        version: '0.1.1',
+                    })
+                        .withRequest('POST', '/matt', (builder) => {
+                        builder.pluginContents('application/matt', mattRequest);
+                    })
+                        .willRespondWith(200, (builder) => {
+                        builder.pluginContents('application/matt', mattResponse);
+                    })
+                        .executeTest((mockserver) => axios_1.default
+                        .request({
+                        baseURL: mockserver.url,
+                        headers: {
+                            'content-type': 'application/matt',
+                            Accept: 'application/matt',
+                        },
+                        data: generateMattMessage('hello'),
+                        method: 'POST',
+                        url: '/matt',
+                    })
+                        .then((res) => {
+                        expect(parseMattMessage(res.data)).to.eq('world');
+                    }));
+                });
             });
-            describe('Synchronous Message (TCP) ', function () {
-                describe('with MATT protocol', function () {
-                    var HOST = '127.0.0.1';
-                    var sendMattMessageTCP = function (message, host, port) {
-                        var socket = net.connect({
-                            port: port,
-                            host: host,
+            describe('Synchronous Message (TCP) ', () => {
+                describe('with MATT protocol', () => {
+                    const HOST = '127.0.0.1';
+                    const sendMattMessageTCP = (message, host, port) => {
+                        const socket = net.connect({
+                            port,
+                            host,
                         });
-                        var res = socket.write("".concat(generateMattMessage(message), "\n"));
+                        const res = socket.write(`${generateMattMessage(message)}\n`);
                         if (!res) {
                             throw Error('unable to connect to host');
                         }
-                        return new Promise(function (resolve) {
-                            socket.on('data', function (data) {
+                        return new Promise((resolve) => {
+                            socket.on('data', (data) => {
                                 resolve(parseMattMessage(data.toString()));
                                 socket.destroy();
                             });
                         });
                     };
-                    it('generates a pact', function () {
-                        var mattMessage = "{\"request\": {\"body\": \"hellotcp\"}, \"response\":{\"body\":\"tcpworld\"}}";
+                    it('generates a pact', () => {
+                        const mattMessage = `{"request": {"body": "hellotcp"}, "response":{"body":"tcpworld"}}`;
                         return pact
                             .addSynchronousInteraction('a MATT message')
                             .usingPlugin({
@@ -399,18 +337,10 @@ describe('V4 Pact', function () {
                         })
                             .withPluginContents(mattMessage, 'application/matt')
                             .startTransport('matt', HOST)
-                            .executeTest(function (tc) { return __awaiter(void 0, void 0, void 0, function () {
-                            var message;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sendMattMessageTCP('hellotcp', HOST, tc.port)];
-                                    case 1:
-                                        message = _a.sent();
-                                        expect(message).to.eq('tcpworld');
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
+                            .executeTest(async (tc) => {
+                            const message = await sendMattMessageTCP('hellotcp', HOST, tc.port);
+                            expect(message).to.eq('tcpworld');
+                        });
                     });
                 });
             });