pmpact 0.4.10 → 0.4.11

package/app/app.js

@@ -44,10 +44,10 @@ function isValidVersion(version) {
 }
 
 const getParser = (version) => {
-    if(isValidVersion(version)){
+    if (isValidVersion(version)) {
         try {
             return require(`./parsers/${version}/pact-parser`);
-        } catch(err) {
+        } catch (err) {
             throw new Error(`Could not find a parser for the pact specification version: ${version}`);
         }
     } else {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "pmpact",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "description": "A command line tool to convert Pact files to Postman collections.",
   "main": "index.js",
   "scripts": {
     "test": "npm run test-unit && npm run test-integration",
-    "test-unit": "mocha --reporter mocha-better-spec-reporter \"tests/unit/**/*.js\"",
-    "test-integration": "mocha --reporter mocha-better-spec-reporter \"tests/integration/**/*.js\""
+    "test-unit": "node  --test 'tests/unit/**/*.js'",
+    "test-integration": "node --test tests/integration/**/*.js"
   },
   "bin": {
     "pmpact": "pmpact.js"
@@ -37,11 +37,7 @@
     "lodash": "4.17.23"
   },
   "devDependencies": {
-    "chai": "4.3.7",
     "execa": "5.1.1",
-    "mocha": "10.8.2",
-    "mocha-better-spec-reporter": "3.1.0",
-    "proxyquire": "2.1.3",
-    "sinon": "15.0.3"
+    "proxyquire": "2.1.3"
   }
 }

package/tests/integration/simple-usage.js

@@ -1,10 +1,14 @@
-const fs = require('fs');
-const util = require('util');
+
+import fs from 'node:fs'
+import util from 'node:util'
+import { describe, afterEach, it } from "node:test"
+import assert from "node:assert/strict";
+import http from 'node:http';
+import execa from 'execa';
+
+import simplePactJson from '../fixtures/v2/simple-pact.json' with { type: 'json' };
+
 const readFile = util.promisify(fs.readFile);
-const assert = require('chai').assert;
-const execa = require('execa');
-const http = require('http');
-const simplePactJson = require('../fixtures/v2/simple-pact.json');
 
 describe('pmpact integration', () => {
 
@@ -21,7 +25,7 @@ describe('pmpact integration', () => {
                 server.close(() => {
                     resolve();
                 });
-            } catch(err) {
+            } catch (err) {
                 resolve();
             }
         });
@@ -34,7 +38,7 @@ describe('pmpact integration', () => {
                 await createServerClosePromise(server);
                 server = undefined;
             }
-        } catch(err) {
+        } catch (err) {
 
         }
     });
@@ -44,7 +48,7 @@ describe('pmpact integration', () => {
             const { stdout, stderr } = await execa('node pmpact.js tests/fixtures/v2/simple-pact.json', undefined, { shell: true });
             assert.ok(isPostmanCollection(stdout));
             assert.equal(stderr, '');
-        } catch(err) {
+        } catch (err) {
             console.log(err);
             assert.ok(0, 'Should not fail');
         }
@@ -60,7 +64,7 @@ describe('pmpact integration', () => {
             const { stdout, stderr } = await execa('node pmpact.js http://localhost:9012', undefined, { shell: true });
             assert.ok(isPostmanCollection(stdout));
             assert.equal(stderr, '');
-        } catch(err) {
+        } catch (err) {
             console.log(err);
             assert.ok(0, 'Should not fail');
         }
@@ -79,7 +83,7 @@ describe('pmpact integration', () => {
             assert.ok(isPostmanCollection(stdout));
             assert.equal(headerAuth, 'Basic ZFhmbHR5Rk1n...');
             assert.equal(stderr, '');
-        } catch(err) {
+        } catch (err) {
             console.log(err);
             assert.ok(0, 'Should not fail');
         }
@@ -92,7 +96,7 @@ describe('pmpact integration', () => {
             const contentJson = (await readFile(FILE_OUTPUT_TEST)).toString('utf8');
             assert.ok(isPostmanCollection(contentJson));
             assert.equal(stderr, '');
-        } catch(err) {
+        } catch (err) {
             console.log(err);
             assert.ok(0, 'Should not fail');
         }
@@ -102,7 +106,7 @@ describe('pmpact integration', () => {
         try {
             await execa('node pmpact.js non-existing-file.json', undefined, { shell: true });
             assert.ok(0, 'Should not be successful');
-        } catch(err) {
+        } catch (err) {
             assert.ok(err.exitCode > 0);
         }
     });

package/tests/unit/app/app.js

@@ -1,84 +1,83 @@
-const assert = require('chai').assert;
-const sinon = require('sinon');
-const proxyquire = require('proxyquire').noCallThru();
-const simplePactV2Json = require('../../fixtures/v2/simple-pact.json');
-const simplePactV3Json = require('../../fixtures/v3/simple-pact.json');
+import { it, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import simplePactV2Json from '../../fixtures/v2/simple-pact.json' with { type: 'json' };
+import simplePactV3Json from '../../fixtures/v3/simple-pact.json' with { type: 'json' };
 
-describe('pmpact > app', () => {
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const proxyquire = require('proxyquire');
 
-    const SIMPLE_PACT_URL_V2 = 'http://simple-pact-v2';
-    const SIMPLE_PACT_URL_V3 = 'http://simple-pact-v3';
 
-    let app
-    let Application;
+describe('pmpact > app', () => {
+
     let axiosStub;
     let fsStub;
 
+    const SIMPLE_PACT_URL_V2 = 'http://simple-pact-v2';
+    const SIMPLE_PACT_URL_V3 = 'http://simple-pact-v3';
+
     const isPostmanCollection = (json) => {
         return JSON.parse(json).info.schema.indexOf('schema.getpostman.com') !== -1;
     };
 
-    beforeEach(() => {
-        axiosStub = sinon.stub({
-            get: () => {}
-        });
-        axiosStub.get.withArgs(SIMPLE_PACT_URL_V2).returns({ data: simplePactV2Json });
-        axiosStub.get.withArgs(SIMPLE_PACT_URL_V3).returns({ data: simplePactV3Json });
-        fsStub = {
-            writeFile: (path, data, opts, cb) => {
-                cb();
+    const getApp = async () => {
+        axiosStub = {
+            get: (url) => {
+                if (url === SIMPLE_PACT_URL_V2) return { data: simplePactV2Json };
+                if (url === SIMPLE_PACT_URL_V3) return { data: simplePactV3Json };
             }
-        }
-        Application = proxyquire('../../../app/app', {
+        };
+
+        fsStub = {
+            writeFile: (path, data, opts, cb) => cb()
+        };
+        const Application = proxyquire('../../../app/app.js', {
             'axios': axiosStub,
             'fs': fsStub
         });
-        app = new Application();
-    });
+        return new Application();
+
+    };
 
-    afterEach(() => {
-        Application = undefined;
-        axiosStub = undefined;
-        fsStub = undefined;
-        app = undefined;
-    });
 
     it('should parse a pact file version 2.0.0', async () => {
+        const app = await getApp();
         const result = await app.parse('./tests/fixtures/v2/simple-pact.json');
         assert.ok(isPostmanCollection(result));
     });
 
     it('should parse a pact url version 2.0.0', async () => {
+        const app = await getApp();
         const result = await app.parse(SIMPLE_PACT_URL_V2);
         assert.ok(isPostmanCollection(result));
     });
 
     it('should parse a pact file version 3.0.0', async () => {
+        const app = await getApp();
         const result = await app.parse('./tests/fixtures/v3/simple-pact.json');
         assert.ok(isPostmanCollection(result));
     });
 
     it('should parse a pact url version 3.0.0', async () => {
+        const app = await getApp();
         const result = await app.parse(SIMPLE_PACT_URL_V3);
         assert.ok(isPostmanCollection(result));
     });
 
     it('should parse a pact url with headers', async () => {
+        const app = await getApp();
         const result = await app.parse(SIMPLE_PACT_URL_V2, '{"Accept":"application/json"}');
-        assert.ok(axiosStub.get.withArgs(SIMPLE_PACT_URL_V2, {
-            headers: {
-                Accept: 'application/json'
-            }
-        }));
         assert.ok(isPostmanCollection(result));
     });
 
     it('should save a collection to a file', async () => {
+        const app = await getApp();
         const result = await app.parse('./tests/fixtures/v2/simple-pact.json', undefined, '~/file-output.json');
         assert.equal(result, 'The collection has been successfully written in ~/file-output.json');
     });
 
     it('should handle errors when saving to a file', async () => {
+        const app = await getApp();
         const error = new Error('Something happened!');
         fsStub.writeFile = (path, data, opts, cb) => {
             cb(error);
@@ -86,44 +85,48 @@ describe('pmpact > app', () => {
         try {
             await app.parse('./tests/fixtures/v2/simple-pact.json', undefined, '~/file-output.json');
             assert.ok(0, 'Should not be successful');
-        } catch(err) {
+        } catch (err) {
             assert.equal(err, error);
         }
     });
 
     it('should not parse a bad url or a non-existing file', async () => {
+        const app = await getApp();
         try {
             await app.parse('something-wrong-here');
             assert.ok(0, 'Should not resolve');
-        } catch(err) {
+        } catch (err) {
             assert.ok(err.message.indexOf('Cannot find module') !== -1);
         }
     });
 
     it('should not parse an unsupported Pact specification', async () => {
+        const app = await getApp();
         try {
             await app.parse('./tests/fixtures/unsupported-pact.json');
             assert.ok(0, 'Should not resolve');
-        } catch(err) {
+        } catch (err) {
             assert.ok(err.message.indexOf('Could not find a parser') !== -1);
         }
     });
 
     it('should default an unspecified pact specification to 2.0.0', async () => {
+        const app = await getApp();
         try {
             const result = await app.parse('./tests/fixtures/unspecified-pact.json');
             assert.ok(isPostmanCollection(result));
-        } catch(err) {
+        } catch (err) {
             assert.ok(0, 'Should not fail');
         }
     });
 
     it('should throw an error when pact version is of incorrect format', async () => {
+        const app = await getApp();
         try {
             await app.parse('./tests/fixtures/invalid-version-pact.json');
             assert.ok(0, 'Should not resolve');
-        } catch(err) {
+        } catch (err) {
             assert.ok(err.message.indexOf('Invalid pact-parser version supplied') !== -1);
         }
     });
-});
+});

package/tests/unit/app/parsers/2.0.0/pact-parser.js

@@ -1,9 +1,8 @@
-const assert = require('chai').assert;
-const sinon = require('sinon');
-const PactParser = require('../../../../../app/parsers/2.0.0/pact-parser');
-
-const simplePactV2Json = require('../../../../fixtures/v2/simple-pact.json');
-const multipleInteractionPactV2Json = require('../../../../fixtures/v2/multiple-interaction-pact.json');
+import { it, beforeEach, afterEach, mock, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import PactParser from '../../../../../app/parsers/2.0.0/pact-parser.js';
+import simplePactV2Json from '../../../../fixtures/v2/simple-pact.json' with { type: 'json' };
+import multipleInteractionPactV2Json from '../../../../fixtures/v2/multiple-interaction-pact.json' with { type: 'json' };
 
 describe('pmpact > app > parsers > 2.0.0 > pact-parser', () => {
 
@@ -37,17 +36,17 @@ describe('pmpact > app > parsers > 2.0.0 > pact-parser', () => {
     });
 
     it('should create a list of requests', () => {
-        var spy = sinon.spy(parser, 'interaction');
+        const spy = mock.method(parser, 'interaction');
         const result = parser.parse(simplePactV2Json);
         assert.equal(result.item.length, 1);
-        assert.ok(spy.calledOnce);
+        assert.equal(spy.mock.calls.length, 1);
     });
 
     it('should parse several interactions', () => {
-        var spy = sinon.spy(parser, 'interaction');
+        const spy = mock.method(parser, 'interaction')
         const result = parser.parse(simplePactV2Json);
         assert.equal(result.item.length, 1);
-        assert.ok(spy.calledOnce);
+        assert.equal(spy.mock.calls.length, 1);
     });
 
     it('should create a request name from the description', () => {
@@ -82,7 +81,7 @@ describe('pmpact > app > parsers > 2.0.0 > pact-parser', () => {
 
     it('should create a host', () => {
         const result = parser.parse(simplePactV2Json);
-        assert.equal(result.item[0].request.url.host, '{{url}}');
+        assert.equal(result.item[0].request.url.host[0], '{{url}}');
     });
 
     it('should create a path', () => {
@@ -123,8 +122,8 @@ describe('pmpact > app > parsers > 2.0.0 > pact-parser', () => {
                 url: {
                     raw: "{{url}}/path1/path2",
                     host: ["{{url}}"],
-                    path: ['path1','path2'],
-                    query: [{key:'p1',value:'p1'},{key:'p2',value:'p2'}],
+                    path: ['path1', 'path2'],
+                    query: [{ key: 'p1', value: 'p1' }, { key: 'p2', value: 'p2' }],
                 }
             },
             _postman_previewlanguage: "json",
@@ -151,4 +150,4 @@ describe('pmpact > app > parsers > 2.0.0 > pact-parser', () => {
             body: '{"data":1}'
         }])
     })
-});
+});

package/tests/unit/app/parsers/3.0.0/pact-parser.js

@@ -1,8 +1,8 @@
-const assert = require('chai').assert;
-const PactParserV2 = require('../../../../../app/parsers/2.0.0/pact-parser');
-const PactParser = require('../../../../../app/parsers/3.0.0/pact-parser');
-
-const simplePactV3Json = require('../../../../fixtures/v3/simple-pact.json');
+import { it, beforeEach, afterEach, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import PactParserV2 from '../../../../../app/parsers/2.0.0/pact-parser.js';
+import PactParser from '../../../../../app/parsers/3.0.0/pact-parser.js';
+import simplePactV3Json from '../../../../fixtures/v3/simple-pact.json' with { type: 'json' };
 
 describe('pmpact > app > parsers > 3.0.0 > pact-parser', () => {
 
@@ -21,8 +21,8 @@ describe('pmpact > app > parsers > 3.0.0 > pact-parser', () => {
     });
 
     it('should extends a parser version 2.0.0', () => {
-        assert.instanceOf(parser, PactParserV2);
-        assert.deepEqual(Object.getOwnPropertyNames(PactParser.prototype), [ 'constructor', 'query' ]);
+        assert.ok(parser instanceof PactParserV2);
+        assert.deepEqual(Object.getOwnPropertyNames(PactParser.prototype), ['constructor', 'query']);
     });
 
     it('should parse a pact source', () => {
@@ -48,4 +48,4 @@ describe('pmpact > app > parsers > 3.0.0 > pact-parser', () => {
         ]);
     });
 
-});
+});

package/tests/unit/pmpact.js

@@ -1,16 +1,20 @@
-const assert = require('chai').assert;
-const sinon = require('sinon');
-const proxyquire = require('proxyquire').noCallThru();
+import { it, beforeEach, afterEach, describe, mock } from 'node:test';
+import assert from 'node:assert/strict';
 
-describe('pmpact', () => {
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const proxyquire = require('proxyquire');
+import packageJson from '../../package.json' with { type: 'json' };
 
+describe('pmpact', () => {
+    let pmpact;
     let commanderStub;
     let applicationStub;
     let source;
     let actionHandler;
 
     const requirePmpact = () => {
-        pmpact = proxyquire('../../pmpact', {
+        pmpact = proxyquire('../../pmpact.js', {
             'commander': commanderStub,
             './app/app': applicationStub
         });
@@ -18,26 +22,24 @@ describe('pmpact', () => {
 
     beforeEach(() => {
         source = 'pact.json';
-        commanderStub = sinon.stub({
-            version: () => {},
-            arguments: () => {},
-            option: () => {},
-            on: () => {},
-            parse: () => {},
-            help: () => {}
-        });
-        commanderStub.version.returns(commanderStub);
-        commanderStub.arguments.returns(commanderStub);
-        commanderStub.option.returns(commanderStub);
-        commanderStub.action = (handler) => {
-            actionHandler = handler;
+
+        commanderStub = {
+            version: mock.fn(() => commanderStub),
+            option: mock.fn(() => commanderStub),
+            arguments: mock.fn(() => commanderStub),
+            on: mock.fn(() => commanderStub),
+            parse: mock.fn(() => commanderStub),
+            help: mock.fn(() => commanderStub),
+            action: (fn) => { actionHandler = fn; },
+            rawArgs: []
         }
-        applicationStub = function(){};
-        commanderStub.rawArgs = [];
-        applicationStub.prototype.parse = sinon.spy();
+        applicationStub = function () { };
+        applicationStub.prototype.parse = mock.fn(() => Promise.resolve());
     });
 
+
     afterEach(() => {
+        mock.reset();
         if (typeof process.exit.restore === 'function') {
             process.exit.restore();
         }
@@ -50,51 +52,53 @@ describe('pmpact', () => {
         commanderStub = undefined;
         applicationStub = undefined;
         source = undefined;
-        originalConsole = undefined;
         actionHandler = undefined;
     });
 
     it('should set a version', () => {
         requirePmpact();
-        assert.ok(commanderStub.version.withArgs(require('../../package.json').version).calledOnce);
+        assert.strictEqual(commanderStub.version.mock.calls.length, 1);
+        assert.strictEqual(commanderStub.version.mock.calls[0].arguments[0], packageJson.version);
     });
 
     it('should set an argument', () => {
         requirePmpact();
-        assert.ok(commanderStub.arguments.withArgs('<file-or-url>').calledOnce);
+        assert.strictEqual(commanderStub.arguments.mock.calls.length, 1);
+        assert.strictEqual(commanderStub.arguments.mock.calls[0].arguments[0], '<file-or-url>');
     });
 
     it('should set a headers option', () => {
         requirePmpact();
-        assert.ok(commanderStub.option.withArgs('-H, --headers <headers>', sinon.match.string).calledOnce);
+        assert.strictEqual(commanderStub.option.mock.calls[0].arguments[0], '-H, --headers <headers>');
+
     });
 
     it('should set an output option', () => {
         requirePmpact();
-        assert.ok(commanderStub.option.withArgs('-o, --output <file>', sinon.match.string).calledOnce);
+        assert.strictEqual(commanderStub.option.mock.calls[1].arguments[0], '-o, --output <file>');
     });
 
     it('should display examples', () => {
-        sinon.stub(console, 'log').callsFake(() => {});
+        console.log = mock.fn();
         requirePmpact();
-        assert.ok(commanderStub.on.withArgs('--help', sinon.match.func).calledOnce);
-        const helpHandler = commanderStub.on.withArgs('--help', sinon.match.func).firstCall.args[1];
+        const helpCall = commanderStub.on.mock.calls.find(call => call.arguments[0] === '--help');
+        assert.ok(helpCall, 'on should be called with --help');
+        const helpHandler = helpCall.arguments[1];
         helpHandler();
-        assert.ok(console.log.withArgs('  Examples').calledOnce);
+        assert.ok(console.log.mock.calls.some(call => call.arguments[0].indexOf('Examples') !== -1), 'Help should display examples');
     });
 
     it('should parse arguments', () => {
         requirePmpact();
-        assert.ok(commanderStub.parse.withArgs(sinon.match.array).calledOnce);
+        assert.strictEqual(commanderStub.parse.mock.calls[0].arguments[0], process.argv);
     });
 
     it('should display help if called with no arguments', () => {
         requirePmpact();
-        assert.ok(commanderStub.help.calledOnce);
+        assert.strictEqual(commanderStub.help.mock.calls.length, 1);
     });
 
     it('should parse a source', () => {
-        sinon.stub(console, 'log').callsFake(() => {});
         proxyquire('../../pmpact', {
             'commander': commanderStub,
             './app/app': applicationStub
@@ -102,14 +106,17 @@ describe('pmpact', () => {
         commanderStub.headers = 'user headers';
         commanderStub.output = 'user output';
         actionHandler(source, commanderStub);
-        assert.ok(applicationStub.prototype.parse.withArgs(source, 'user headers', 'user output').calledOnce);
+        assert.strictEqual(applicationStub.prototype.parse.mock.calls[0].arguments[0], source);
+        assert.strictEqual(applicationStub.prototype.parse.mock.calls[0].arguments[1], 'user headers');
+        assert.strictEqual(applicationStub.prototype.parse.mock.calls[0].arguments[2], 'user output');
     });
 
     it('should handle errors', () => {
-        sinon.stub(console, 'error');
-        sinon.stub(process, 'exit');
+        console.error = mock.fn();
+        process.exit = mock.fn();
+
         const error = new Error('Something happened');
-        applicationStub.prototype.parse = function() {
+        applicationStub.prototype.parse = function () {
             throw error;
         };
         proxyquire('../../pmpact', {
@@ -117,8 +124,8 @@ describe('pmpact', () => {
             './app/app': applicationStub
         });
         actionHandler(source, commanderStub);
-        assert.ok(process.exit.withArgs(1).calledOnce);
-        assert.ok(console.error.withArgs(error).calledOnce);
+        assert.strictEqual(console.error.mock.calls[0].arguments[0], error);
+        assert.strictEqual(process.exit.mock.calls[0].arguments[0], 1);
     });
 
 });