@fanoutio/pubcontrol - npm Package Compare versions

Comparing version 2.1.4 to 2.1.5

build/engine/PubControlClient.d.ts

@@ -7,3 +7,3 @@ /// <reference types="node" />
 import IItemExport from "../data/IItemExport";
-interface IHeaders {
+interface IReqHeaders {
     [name: string]: string;
@@ -13,6 +13,11 @@ }
     method: string;
-    headers: IHeaders;
+    headers: IReqHeaders;
     body: string;
     agent?: HttpAgent;
 }
+interface IContext {
+    statusCode: number;
+    headers?: object;
+    httpBody?: any;
+}
 interface FetchResponse {
@@ -37,4 +42,4 @@ status: number;
     _performHttpRequest(transport: Transport, uri: string, reqParams: IReqParams): Promise<void>;
-    _finishHttpRequest(mode: string, httpData: any, context: any): void;
+    _finishHttpRequest(mode: string, httpData: any, context: IContext): void;
 }
 export {};

build/index.es.js

@@ -126,3 +126,3 @@ import { Buffer as Buffer$1 } from 'buffer';
         // was provided then treat it as the literal token.
-        if (args.length == 1) {
+        if (args.length === 1) {
             _this.token = args[0];
@@ -168,2 +168,5 @@ _this.claim = undefined;
 // implementations include JsonObjectFormat and HttpStreamFormat.
+// In pure TypeScript this would not be needed (implementations would
+// only need to implement IFormat), but since this needs to be consumable
+// from JavaScript, we are exporting this class.
 var Format = /** @class */ (function () {
@@ -1203,3 +1206,3 @@ function Format() {
                             statusCode: res.status,
-                            headers: res.headers
+                            headers: res.headers,
                         };
@@ -1206,0 +1209,0 @@ _a.label = 5;

build/index.js

@@ -131,3 +131,3 @@ 'use strict';
         // was provided then treat it as the literal token.
-        if (args.length == 1) {
+        if (args.length === 1) {
             _this.token = args[0];
@@ -173,2 +173,5 @@ _this.claim = undefined;
 // implementations include JsonObjectFormat and HttpStreamFormat.
+// In pure TypeScript this would not be needed (implementations would
+// only need to implement IFormat), but since this needs to be consumable
+// from JavaScript, we are exporting this class.
 var Format = /** @class */ (function () {
@@ -1208,3 +1211,3 @@ function Format() {
                             statusCode: res.status,
-                            headers: res.headers
+                            headers: res.headers,
                         };
@@ -1211,0 +1214,0 @@ _a.label = 5;

demo/index.js

 // DEMO - Publishes test message to local Pushpin.
 // See README.md for directions on running this demo.
-const PubControl = require('../commonjs');
+const PubControl = require('..');
 const { Item, Format } = PubControl;
@@ -5,0 +5,0 @@

package.json

 {
   "name": "@fanoutio/pubcontrol",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "author": "Fanout, Inc. <[e-mail]>",
@@ -36,4 +36,4 @@ "description": "EPCP Library",
     "build-browser:build": "rollup -c rollup.browser.config.js",
-    "lint": "npm run lint:eslint",
-    "lint:eslint": "eslint --ext=.js src/* tests/*",
+    "lint": "npm run lint:tslint",
+    "lint:tslint": "tslint -c tslint.json 'src/**/*.ts' 'test/**/*.ts'",
     "test": "TS_NODE_FILES=true TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register tests/*.ts"
@@ -70,4 +70,5 @@ },
     "tslib": "^1.11.1",
+    "tslint": "^6.1.1",
     "typescript": "^3.8.3"
   }
 }

README.md

@@ -22,2 +22,8 @@ # PubControl for JavaScript
 
+## Installation
+
+```sh
+npm install @fanoutio/pubcontrol
+```
+
 ## Sample Usage
@@ -155,29 +161,31 @@
 
-### ESM
+### CommonJS  
 
-If you are using Node 12.0 or newer or building a bundle for a browser using a
-modern bundler, you can use this package as an ESM module.  Install it as an
-npm package:
+The CommonJS version of this package requires Node v8 or newer.
 
-```bash
-npm install @fanoutio/pubcontrol
+Require in your JavaScript:
+
+```javascript
+const PubControl = require('@fanoutio/pubcontrol');
+const { Format, Item } = PubControl;
+const pub = new PubControl({uri: "<endpoint_uri>"});
 ```
 
-Import in your JavaScript:
+If you are building a bundle, you may also import in your JavaScript.
 
 ```javascript
-import PubControl, { Item, Format, } from '@fanoutio/pubcontrol';
+import PubControl from '@fanoutio/pubcontrol';
+const { Format, Item } = PubControl;
 const pub = new PubControl({uri: "<endpoint_uri>"});
 ```
 
-### CommonJS  
+This package comes with full TypeScript type definitions, so you may use it with
+TypeScript as well.
 
-The CommonJS version of this package requires Node v8 or newer.
-
-Require in your JavaScript:
-
 ```javascript
-const PubControl = require('@fanoutio/pubcontrol');
+import PubControl, { IFormat } from '@fanoutio/pubcontrol';
 const { Format, Item } = PubControl;
 const pub = new PubControl({uri: "<endpoint_uri>"});
+
+// IFormat is a type declaration.
 ```
@@ -184,0 +192,0 @@

rollup.browser.config.js

@@ -40,5 +40,5 @@ import nodeGlobals from 'rollup-plugin-node-globals';
             declaration: false,
-            esModuleInterop: false
+            esModuleInterop: false,
         }),
     ],
 };

src/data/Format.ts

@@ -8,2 +8,6 @@ import IFormat from "./IFormat";
 
+// In pure TypeScript this would not be needed (implementations would
+// only need to implement IFormat), but since this needs to be consumable
+// from JavaScript, we are exporting this class.
+
 export default abstract class Format implements IFormat {
@@ -10,0 +14,0 @@ // The name of the format which should return a string. Examples

src/engine/PubControlClient.ts

@@ -12,3 +12,3 @@ import { Buffer } from 'buffer';
 
-interface IHeaders {
+interface IReqHeaders {
     [name: string]: string;
@@ -18,6 +18,11 @@ }
     method: string;
-    headers: IHeaders;
+    headers: IReqHeaders;
     body: string;
     agent?: HttpAgent;
 }
+interface IContext {
+    statusCode: number,
+    headers?: object,
+    httpBody?: any,
+}
 interface FetchResponse {
@@ -77,3 +82,3 @@ status: number;
         // Build HTTP headers
-        const headers: IHeaders = {
+        const headers: IReqHeaders = {
             "Content-Type": "application/json",
@@ -119,5 +124,5 @@ "Content-Length": "" + Buffer.byteLength( content, "utf8"),
 
-        const context = {
+        const context: IContext = {
             statusCode: res.status,
-            headers: res.headers
+            headers: res.headers,
         };
@@ -138,3 +143,3 @@ let mode;
     // a message.
-    _finishHttpRequest(mode: string, httpData: any, context: any) {
+    _finishHttpRequest(mode: string, httpData: any, context: IContext) {
         context.httpBody = httpData;
@@ -141,0 +146,0 @@ if (mode === "end") {

src/utils/auth/Jwt.ts

@@ -20,4 +20,4 @@ import { Buffer } from 'buffer';
         // was provided then treat it as the literal token.
-        if (args.length == 1) {
-            this.token = <string>args[0];
+        if (args.length === 1) {
+            this.token = args[0] as string;
             this.claim = undefined;
@@ -27,3 +27,3 @@ this.key = undefined;
             this.token = undefined;
-            this.claim = <object>args[0];
+            this.claim = args[0] as object;
             this.key = args[1] instanceof Buffer ? args[1] : Buffer.from( String(args[1]), "utf8" );
@@ -30,0 +30,0 @@ }

tests/Item-tests.ts

@@ -100,4 +100,1 @@ import assert from "assert";
 });
-
-(function testExport() {
-})();

tests/PubControl-tests.ts

@@ -5,7 +5,5 @@ import assert from "assert";
 import PubControlClient from "../src/engine/PubControlClient";
-/*
 import PublishException from "../src/data/PublishException";
-import Jwt from "../src/utils/auth/Jwt";
 import Item from "../src/data/Item";
-*/
+import IItem from "../src/data/IItem";
 
@@ -64,145 +62,138 @@ describe('PubControl', function () {
     });
-    describe('#applyConfig', function () {
-        it('test case', function () {
+    describe('#publish', function () {
+        it('test case', async function () {
+            let wasPublishCalled = false;
+            const testItem = <Item>{};
+            const pc = new PubControl();
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    wasPublishCalled = true;
+                }
+            });
+            await pc.publish("chan", testItem);
+            assert(wasPublishCalled);
         });
+        it('callback', function(done) {
+            let callbackResult: any = null;
+            const testItem = <Item>{};
+            let calls = 2;
+            const pc = new PubControl();
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    calls--;
+                }
+            });
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    calls--;
+                }
+            });
+            pc.publish("chan", testItem, (flag, message, context) => {
+                callbackResult = { flag, message, context };
+                done();
+            });
+            after(function() {
+                assert.equal(calls, 0);
+                assert.ok(callbackResult.flag);
+                assert.equal(callbackResult.message, null);
+                assert.equal(callbackResult.context, null);
+            });
+        });
+        it('callback fail', function(done) {
+            let results: any = null;
+            const testItem = <Item>{};
+            const pc = new PubControl();
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel: string, item: IItem) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                }
+            });
+            pc.addClient(<PubControlClient><unknown>{
+                publish: async function (channel: string, item: IItem) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    throw new PublishException("error 2", {value: 2});
+                }
+            });
+            pc.addClient(<PubControlClient><unknown>{
+                publish: async function (channel: string, item: IItem) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    throw new PublishException("error 3", {value: 3});
+                }
+            });
+            pc.publish("chan", testItem, (flag, message, context) => {
+                results = { flag, message, context };
+                done();
+            });
+            after(function() {
+                assert.notEqual(results, null);
+                assert.equal(results.flag, false);
+                assert.equal(results.message, "error 2");
+                assert.equal(results.context.value, 2)
+            });
+        });
+        it('async', async function() {
+            const testItem = <Item>{};
+            let calls = 2;
+            const pc = new PubControl();
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    calls--;
+                }
+            });
+            pc.addClient(<PubControlClient>{
+                publish: async function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    calls--;
+                }
+            });
+            await pc.publish("chan", testItem);
+            assert.equal(calls, 0);
+        });
+        it('async fail', async function() {
+            const testItem = <Item>{};
+            const pc = new PubControl();
+            pc.addClient(<PubControlClient>{
+                publish: function (channel, item) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                }
+            });
+            pc.addClient(<PubControlClient><unknown>{
+                publish: function (channel: string, item: IItem) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    throw new PublishException("error 2", {value: 2});
+                }
+            });
+            pc.addClient(<PubControlClient><unknown>{
+                publish: function (channel: string, item: IItem) {
+                    assert.equal(channel, "chan");
+                    assert.equal(item, testItem);
+                    throw new PublishException("error 3", {value: 3});
+                }
+            });
+            let resultEx: any = null;
+            await assert.rejects(async () => {
+                await pc.publish("chan", testItem);
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert.ok(resultEx instanceof PublishException);
+            assert.equal(resultEx.message, "error 2");
+            assert.equal(resultEx.context.value, 2);
+        });
     });
 });
-
-/*
-(async function testPublish() {
-    let wasPublishCalled = false;
-    const testItem = <Item>{};
-    const pc = new PubControl();
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            wasPublishCalled = true;
-        }
-    });
-    await pc.publish("chan", testItem);
-    assert(wasPublishCalled);
-})();
-
-(function testPublishCallback() {
-    let callbackResult = null;
-    const testItem = <Item>{};
-    let calls = 2;
-    const pc = new PubControl();
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            calls--;
-        }
-    });
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            calls--;
-        }
-    });
-    pc.publish("chan", testItem, (flag, message, context) => {
-        callbackResult = { flag, message, context };
-    });
-    process.on('beforeExit', () => {
-        assert.equal(calls, 0);
-        assert.ok(callbackResult.flag);
-        assert.equal(callbackResult.message, null);
-        assert.equal(callbackResult.context, null);
-    });
-})();
-
-(function testPublishCallbackFail() {
-    let results = null;
-    const testItem = <Item>{};
-    const pc = new PubControl();
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-        }
-    });
-    pc.addClient(<PubControlClient><unknown>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            throw new PublishException("error 2", {value: 2});
-        }
-    });
-    pc.addClient(<PubControlClient><unknown>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            throw new PublishException("error 3", {value: 3});
-        }
-    });
-    pc.publish("chan", testItem, (flag, message, context) => {
-        results = { flag, message, context };
-    });
-    process.on('beforeExit', () => {
-        assert.notEqual(results, null);
-        assert.equal(results.flag, false);
-        assert.equal(results.message, "error 2");
-        assert.equal(results.context.value, 2)
-    });
-})();
-
-(async function testPublishAsync() {
-    const testItem = <Item>{};
-    let calls = 2;
-    const pc = new PubControl();
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            calls--;
-        }
-    });
-    pc.addClient(<PubControlClient>{
-        publish: async function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            calls--;
-        }
-    });
-    await pc.publish("chan", testItem);
-    assert.equal(calls, 0);
-})();
-
-(async function testPublishAsyncFail() {
-    const testItem = <Item>{};
-    const pc = new PubControl();
-    pc.addClient(<PubControlClient>{
-        publish: function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-        }
-    });
-    pc.addClient(<PubControlClient><unknown>{
-        publish: function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            throw new PublishException("error 2", {value: 2});
-        }
-    });
-    pc.addClient(<PubControlClient><unknown>{
-        publish: function (channel, item) {
-            assert.equal(channel, "chan");
-            assert.equal(item, testItem);
-            throw new PublishException("error 3", {value: 3});
-        }
-    });
-    let resultEx = null;
-    await assert.rejects(async () => {
-        await pc.publish("chan", testItem);
-    }, ex => {
-        resultEx = ex;
-        return true;
-    });
-    assert.ok(resultEx instanceof PublishException);
-    assert.equal(resultEx.message, "error 2");
-    assert.equal(resultEx.context.value, 2)
-})();
-*/

tests/PubControlClient-tests.ts

@@ -1,2 +0,1 @@
-/*
 import assert from "assert";
@@ -10,6 +9,7 @@
 import Jwt from "../src/utils/auth/Jwt";
+import IItemExport from "../src/data/IItemExport";
 
 class TestFormat extends Format {
-    content;
-    constructor(content) {
+    content: string;
+    constructor(content: string) {
         super();
@@ -26,259 +26,269 @@ this.content = content;
 
-(function testInitialize() {
-    const pcc = new PubControlClient("uri");
-    assert.equal(pcc.uri, "uri");
-    assert.equal(pcc.auth, null);
-    assert.notEqual(pcc.httpKeepAliveAgent, null);
-    assert.notEqual(pcc.httpsKeepAliveAgent, null);
-})();
-
-(function testSetAuthBasic() {
-    const pcc = new PubControlClient("uri");
-    pcc.setAuthBasic("user", "pass");
-    assert.equal((<Basic>pcc.auth).user, "user");
-    assert.equal((<Basic>pcc.auth).pass, "pass");
-})();
-
-(function testSetAuthJwt() {
-    let pcc = new PubControlClient("uri");
-    const claim = {};
-    pcc.setAuthJwt(claim, "key");
-    assert.equal((<Jwt>pcc.auth).claim, claim);
-    assert.equal((<Jwt>pcc.auth).key, "key");
-    pcc = new PubControlClient("uri");
-    pcc.setAuthJwt("token");
-    assert.equal((<Jwt>pcc.auth).token, "token");
-})();
-
-(async function testPublish() {
-    let wasWorkerCalled = false;
-    const itm = new Item(new TestFormat("bodyval"));
-    const exportedItem = itm.export();
-    exportedItem["channel"] = "channel";
-    const pcc = new PubControlClient("uri");
-    pcc._startPubCall = async function(uri, authHeader, items) {
-        assert.equal(uri, "uri");
-        assert.equal(
-            authHeader,
-            "Basic " + Buffer.from("user:pass").toString("base64")
-        );
-        assert.equal(JSON.stringify(items), JSON.stringify([exportedItem]));
-        wasWorkerCalled = true;
-    };
-    pcc.setAuthBasic("user", "pass");
-    await pcc.publish("channel", itm);
-    assert(wasWorkerCalled);
-})();
-
-(async function testPublishNoAuth() {
-    let wasWorkerCalled = false;
-    const itm = new Item(new TestFormat("bodyval"));
-    const exportedItem = itm.export();
-    exportedItem["channel"] = "channel";
-    const pcc = new PubControlClient("uri");
-    pcc._startPubCall = async function(uri, authHeader, items) {
-        assert.equal(uri, "uri");
-        assert.equal(authHeader, null);
-        assert.equal(JSON.stringify(items), JSON.stringify([exportedItem]));
-        wasWorkerCalled = true;
-    };
-    await pcc.publish("channel", itm);
-    assert(wasWorkerCalled);
-})();
-
-(async function testPublishFail() {
-    const itm = new Item(new TestFormat("bodyval"));
-    const exportedItem = itm.export();
-    exportedItem["channel"] = "channel";
-    const pcc = new PubControlClient("uri");
-    pcc._startPubCall = async function(uri, authHeader, items) {
-        throw new PublishException('fail', null);
-    };
-    let resultEx = null;
-    await assert.rejects(async () => {
-        await pcc.publish("channel", itm);
-    }, ex => {
-        resultEx = ex;
-        return true;
+describe('PubControlClient', function() {
+    describe('#constructor', function() {
+        it('test case', function() {
+            const pcc = new PubControlClient("uri");
+            assert.equal(pcc.uri, "uri");
+            assert.equal(pcc.auth, null);
+            assert.notEqual(pcc.httpKeepAliveAgent, null);
+            assert.notEqual(pcc.httpsKeepAliveAgent, null);
+        });
     });
-    assert(resultEx instanceof PublishException);
-    assert.strictEqual(resultEx.message, "fail");
-})();
-
-(async function testStartPubCall() {
-    const pcc = new PubControlClient("http://uri.com");
-    const testItems = [];
-    let wasPerformHttpRequestCalled = false;
-    pcc._performHttpRequest = async function(transport, uri, reqParams) {
-        assert.equal(reqParams.body, JSON.stringify({ items: testItems }));
-        assert.equal(reqParams.method, "POST");
-        assert.equal(reqParams.headers["Content-Type"], "application/json");
-        assert.equal(
-            reqParams.headers["Content-Length"],
-            Buffer.byteLength(reqParams.body, "utf8")
-        );
-        assert.equal(reqParams.headers["Authorization"], "authHeader");
-        assert.equal(uri, "http://uri.com/publish/");
-        assert.equal(pcc.httpKeepAliveAgent, reqParams.agent);
-        wasPerformHttpRequestCalled = true;
-    };
-    await pcc._startPubCall("http://uri.com", "authHeader", testItems);
-    assert(wasPerformHttpRequestCalled);
-})();
-
-(async function testStartPubCallHttps() {
-    const pcc = new PubControlClient("https://uri.com");
-    const testItems = [];
-    let wasPerformHttpRequestCalled = false;
-    pcc._performHttpRequest = async function(transport, uri, reqParams) {
-        assert.equal(reqParams.body, JSON.stringify({ items: testItems }));
-        assert.equal(reqParams.method, "POST");
-        assert.equal(reqParams.headers["Content-Type"], "application/json");
-        assert.equal(
-            reqParams.headers["Content-Length"],
-            Buffer.byteLength(reqParams.body, "utf8")
-        );
-        assert(!("Authorization" in reqParams.headers));
-        assert.equal(uri, "https://uri.com/publish/");
-        assert.equal(pcc.httpsKeepAliveAgent, reqParams.agent);
-        wasPerformHttpRequestCalled = true;
-    };
-    await pcc._startPubCall("https://uri.com", null, testItems);
-    assert(wasPerformHttpRequestCalled);
-})();
-
-(async function testStartPubCallBadUri() {
-    const pcc = new PubControlClient("https://uri.com");
-    const testItems = [];
-    let resultEx = null;
-    await assert.rejects(async () => {
-        await pcc._startPubCall("file://uri.com", null, testItems);
-    }, ex => {
-        resultEx = ex;
-        return true;
+    describe('#setAuthBasic', function() {
+        it('test case', function() {
+            const pcc = new PubControlClient("uri");
+            pcc.setAuthBasic("user", "pass");
+            assert.equal((<Basic>pcc.auth).user, "user");
+            assert.equal((<Basic>pcc.auth).pass, "pass");
+        });
     });
-    assert(resultEx instanceof PublishException);
-    assert.equal(resultEx.message, "Bad URI");
-    assert.equal(resultEx.context.statusCode, -2);
-})();
-
-(function testFinishHttpRequest() {
-    const pcc = new PubControlClient("https://uri.com");
-    assert.doesNotThrow(() => {
-        pcc._finishHttpRequest(
-            "end",
-            ["result"],
-            { statusCode: 200 }
-        );
+    describe('#setAuthJwt', function() {
+        it('key and claim', function() {
+            const pcc = new PubControlClient("uri");
+            const claim = {};
+            pcc.setAuthJwt(claim, "key");
+            assert.equal((<Jwt>pcc.auth).claim, claim);
+            assert.equal((<Jwt>pcc.auth).key, "key");
+        });
+        it('token', function() {
+            const pcc = new PubControlClient("uri");
+            pcc.setAuthJwt("token");
+            assert.equal((<Jwt>pcc.auth).token, "token");
+        });
     });
-})();
-
-(function testFinishHttpRequestFailure() {
-    const pcc = new PubControlClient("https://uri.com");
-    let resultEx = null;
-    assert.throws(() => {
-        pcc._finishHttpRequest( "end", "result", { statusCode: 300 } );
-    }, ex => {
-        resultEx = ex;
-        return true;
+    describe('#publish', function() {
+        it('auth', async function() {
+            let wasWorkerCalled = false;
+            const itm = new Item(new TestFormat("bodyval"));
+            const exportedItem = itm.export();
+            exportedItem["channel"] = "channel";
+            const pcc = new PubControlClient("uri");
+            pcc._startPubCall = async function(uri, authHeader, items) {
+                assert.equal(uri, "uri");
+                assert.equal(
+                    authHeader,
+                    "Basic " + Buffer.from("user:pass").toString("base64")
+                );
+                assert.equal(JSON.stringify(items), JSON.stringify([exportedItem]));
+                wasWorkerCalled = true;
+            };
+            pcc.setAuthBasic("user", "pass");
+            await pcc.publish("channel", itm);
+            assert(wasWorkerCalled);
+        });
+        it('no auth', async function() {
+            let wasWorkerCalled = false;
+            const itm = new Item(new TestFormat("bodyval"));
+            const exportedItem = itm.export();
+            exportedItem["channel"] = "channel";
+            const pcc = new PubControlClient("uri");
+            pcc._startPubCall = async function(uri, authHeader, items) {
+                assert.equal(uri, "uri");
+                assert.equal(authHeader, null);
+                assert.equal(JSON.stringify(items), JSON.stringify([exportedItem]));
+                wasWorkerCalled = true;
+            };
+            await pcc.publish("channel", itm);
+            assert(wasWorkerCalled);
+        });
+        it('fail', async function() {
+            const itm = new Item(new TestFormat("bodyval"));
+            const exportedItem = itm.export();
+            exportedItem["channel"] = "channel";
+            const pcc = new PubControlClient("uri");
+            pcc._startPubCall = async function() {
+                throw new PublishException('fail', null);
+            };
+            let resultEx: any = null;
+            await assert.rejects(async () => {
+                await pcc.publish("channel", itm);
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert(resultEx instanceof PublishException);
+            assert.strictEqual(resultEx.message, "fail");
+        });
     });
-    assert.ok(resultEx instanceof PublishException);
-    assert.equal(resultEx.message, '\"result\"');
-    assert.equal(resultEx.context.statusCode, 300);
-})();
-
-(function testFinishHttpRequestClose() {
-    const pcc = new PubControlClient("https://uri.com");
-    let resultEx = null;
-    assert.throws(() => {
-        pcc._finishHttpRequest( "close", "result", { statusCode: 300 } );
-    }, ex => {
-        resultEx = ex;
-        return true;
+    describe('#_startPubCall', function() {
+        it('test', async function() {
+            const pcc = new PubControlClient("http://uri.com");
+            const testItems: IItemExport[] = [];
+            let wasPerformHttpRequestCalled = false;
+            pcc._performHttpRequest = async function(_transport, uri, reqParams) {
+                assert.equal(reqParams.body, JSON.stringify({ items: testItems }));
+                assert.equal(reqParams.method, "POST");
+                assert.notEqual(reqParams.headers, null);
+                assert.equal(reqParams.headers["Content-Type"], "application/json");
+                assert.equal(
+                    reqParams.headers["Content-Length"],
+                    Buffer.byteLength(reqParams.body, "utf8")
+                );
+                assert.equal(reqParams.headers["Authorization"], "authHeader");
+                assert.equal(uri, "http://uri.com/publish/");
+                assert.equal(pcc.httpKeepAliveAgent, reqParams.agent);
+                wasPerformHttpRequestCalled = true;
+            };
+            await pcc._startPubCall("http://uri.com", "authHeader", testItems);
+            assert(wasPerformHttpRequestCalled);
+        });
+        it('https', async function() {
+            const pcc = new PubControlClient("https://uri.com");
+            const testItems: IItemExport[] = [];
+            let wasPerformHttpRequestCalled = false;
+            pcc._performHttpRequest = async function(_transport, uri, reqParams) {
+                assert.equal(reqParams.body, JSON.stringify({ items: testItems }));
+                assert.equal(reqParams.method, "POST");
+                assert.equal(reqParams.headers["Content-Type"], "application/json");
+                assert.equal(
+                    reqParams.headers["Content-Length"],
+                    Buffer.byteLength(reqParams.body, "utf8")
+                );
+                assert(!("Authorization" in reqParams.headers));
+                assert.equal(uri, "https://uri.com/publish/");
+                assert.equal(pcc.httpsKeepAliveAgent, reqParams.agent);
+                wasPerformHttpRequestCalled = true;
+            };
+            await pcc._startPubCall("https://uri.com", null, testItems);
+            assert(wasPerformHttpRequestCalled);
+        });
+        it('bad uri', async function() {
+            const pcc = new PubControlClient("https://uri.com");
+            const testItems: IItemExport[] = [];
+            let resultEx: any = null;
+            await assert.rejects(async () => {
+                await pcc._startPubCall("file://uri.com", null, testItems);
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert(resultEx instanceof PublishException);
+            assert.equal(resultEx.message, "Bad URI");
+            assert.equal(resultEx.context.statusCode, -2);
+        });
     });
-    assert.ok(resultEx instanceof PublishException);
-    assert.equal(resultEx.message, 'Connection closed unexpectedly');
-    assert.equal(resultEx.context.statusCode, 300);
-})();
+    describe('#_finishHttpRequest', function() {
+        const pcc = new PubControlClient("https://uri.com");
+        it('test', async function() {
+            assert.doesNotThrow(() => {
+                pcc._finishHttpRequest(
+                    "end",
+                    ["result"],
+                    { statusCode: 200 }
+                );
+            });
+        });
+        it('failure', async function() {
+            let resultEx: any = null;
+            assert.throws(() => {
+                pcc._finishHttpRequest( "end", "result", { statusCode: 300 } );
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert.ok(resultEx instanceof PublishException);
+            assert.equal(resultEx.message, '\"result\"');
+            assert.equal(resultEx.context.statusCode, 300);
+        });
+        it('request close', function() {
+            let resultEx: any = null;
+            assert.throws(() => {
+                pcc._finishHttpRequest( "close", "result", { statusCode: 300 } );
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert.ok(resultEx instanceof PublishException);
+            assert.equal(resultEx.message, 'Connection closed unexpectedly');
+            assert.equal(resultEx.context.statusCode, 300);
+        });
+    });
+    describe('#_performHttpRequest', function() {
+        let wasFinishHttpRequestCalled: boolean;
+        let wasFinishHttpRequestCalledForClose: boolean;
+        const pcc = new PubControlClient("https://uri.com");
+        pcc._finishHttpRequest = (mode, httpData) => {
+            wasFinishHttpRequestCalled = false;
+            wasFinishHttpRequestCalledForClose = false;
+            if (mode === "end") {
+                wasFinishHttpRequestCalled = true;
+                assert.equal(httpData, "result");
+            }
+            if (mode === "close") {
+                wasFinishHttpRequestCalledForClose = true;
+            }
+        };
 
-(async function testPerformHttpRequest() {
-    let wasFinishHttpRequestCalled = false;
-    let wasFinishHttpRequestCalledForClose = false;
-    const pcc = new PubControlClient("https://uri.com");
+        beforeEach(function() {
+            wasFinishHttpRequestCalled = false;
+            wasFinishHttpRequestCalledForClose = false;
+        });
 
-    pcc._finishHttpRequest = (mode, httpData, context) => {
-        wasFinishHttpRequestCalled = false;
-        wasFinishHttpRequestCalledForClose = false;
-        if (mode === "end") {
-            wasFinishHttpRequestCalled = true;
-            assert.equal(httpData, "result");
-        }
-        if (mode === "close") {
-            wasFinishHttpRequestCalledForClose = true;
-        }
-    };
+        it('fail', async function() {
+            const failTransport = async (_ur: any, opts: any) => {
+                assert.equal(opts.body, "content");
+                throw {message: "message"};
+            };
 
-    const failTransport = async (uri, opts) => {
-        assert.equal(opts.body, "content");
-        throw { message: "message" };
-    };
+            let resultEx: any = null;
+            await assert.rejects(async () => {
+                await pcc._performHttpRequest(failTransport, "https://uri.com/publish/", {
+                    agent: undefined,
+                    headers: {},
+                    method: "",
+                    body: "content"
+                });
+            }, ex => {
+                resultEx = ex;
+                return true;
+            });
+            assert.ok(resultEx instanceof PublishException);
+            assert.equal(resultEx.message, "message");
+            assert.equal(resultEx.context.statusCode, -1);
+            assert(!wasFinishHttpRequestCalled);
+            assert(!wasFinishHttpRequestCalledForClose);
+        });
+        it('close', async function() {
+            const closeTransport = async (_uri: any, opts: any) => {
+                assert.equal(opts.body, "content");
+                return {
+                    status: 200,
+                    headers: {},
+                    text: async () => {
+                        throw "error";
+                    },
+                };
+            };
 
-    let resultEx = null;
-    await assert.rejects(async () => {
-        await pcc._performHttpRequest(failTransport, "https://uri.com/publish/", {
-            agent: undefined,
-            headers: undefined,
-            method: "",
-            body: "content"
+            await pcc._performHttpRequest(closeTransport, "https://uri.com/publish/", {
+                agent: undefined,
+                headers: {},
+                method: "",
+                body: "content"
+            });
+            assert(!wasFinishHttpRequestCalled);
+            assert(wasFinishHttpRequestCalledForClose);
         });
-    }, ex => {
-        resultEx = ex;
-        return true;
-    });
-    assert.ok(resultEx instanceof PublishException);
-    assert.equal(resultEx.message, "message");
-    assert.equal(resultEx.context.statusCode, -1);
-    assert(!wasFinishHttpRequestCalled);
-    assert(!wasFinishHttpRequestCalledForClose);
+        it('success', async function() {
+            const successTransport = async (_uri: any, opts: any) => {
+                assert.equal(opts.body, "content");
+                return {
+                    status: 200,
+                    headers: {},
+                    text: async () => {
+                        return "result";
+                    },
+                };
+            };
 
-    const closeTransport = async (uri, opts) => {
-        assert.equal(opts.body, "content");
-        return {
-            status: 200,
-            headers: {},
-            text: async () => {
-                throw "error";
-            },
-        };
-    };
-
-    await pcc._performHttpRequest(closeTransport, "https://uri.com/publish/", {
-        agent: undefined,
-        headers: undefined,
-        method: "",
-        body: "content"
+            await pcc._performHttpRequest(successTransport, "https://uri.com/publish/", {
+                agent: undefined,
+                headers: {},
+                method: "",
+                body: "content"
+            });
+            assert(wasFinishHttpRequestCalled);
+            assert(!wasFinishHttpRequestCalledForClose);
+        });
     });
-    assert(!wasFinishHttpRequestCalled);
-    assert(wasFinishHttpRequestCalledForClose);
-
-    const successTransport = async (uri, opts) => {
-        assert.equal(opts.body, "content");
-        return {
-            status: 200,
-            headers: {},
-            text: async () => {
-                return "result";
-            },
-        };
-    };
-
-    await pcc._performHttpRequest(successTransport, "https://uri.com/publish/", {
-        agent: undefined,
-        headers: undefined,
-        method: "",
-        body: "content"
-    });
-    assert(wasFinishHttpRequestCalled);
-    assert(!wasFinishHttpRequestCalledForClose);
-})();
-*/
+});

No alert changes

Improved metrics

Total package byte prevSize

582938

increased by0.91%

Lines of code

10258

increased by0.33%

Number of lines in readme file

255

increased by3.24%

Worsened metrics

Dev dependency count

17

increased by6.25%

Number of package files

64

decreased by-1.54%

No dependency changes