btrz-api-client 3.29.0 → 3.33.0

package/src/endpoints/gps/scanner-app-location.js

@@ -0,0 +1,18 @@
+const {authorizationHeaders} = require("./../endpoints_helpers.js");
+
+//TODO: add docs function when docs published
+function scannerAppLocationFactory({client}) {
+  function get({token, query = {}}) {
+    return client({
+      url: "/scanner-app-location",
+      headers: authorizationHeaders({token}),
+      params: query
+    });
+  }
+
+  return {
+    get
+  };
+}
+
+module.exports = scannerAppLocationFactory;

package/src/endpoints/invoices/emails.js

@@ -0,0 +1,19 @@
+const {authorizationHeaders} = require("./../endpoints_helpers");
+
+function emailsFactory({client, internalAuthTokenProvider}) {
+  function create({token, jwtToken, data, query = {}}) {
+    return client({
+      url: "/emails",
+      method: "post",
+      headers: authorizationHeaders({token, jwtToken, internalAuthTokenProvider}),
+      params: query,
+      data
+    });
+  }
+
+  return {
+    create
+  };
+}
+
+module.exports = emailsFactory;

package/test/client.test.js

@@ -1,7 +1,8 @@
-const { expect } = require("chai");
-const MockAdapter = require('axios-mock-adapter');
+const {expect} = require("chai");
+const MockAdapter = require("axios-mock-adapter");
 
-const { createApiClient } = require("./../src/client");
+const {createApiClient} = require("./../src/client.js");
+const {createTestServer, axiosMock} = require("./test-helpers.js");
 
 function expectKnownEndpoints(api) {
   expect(api.inventory.products).to.exist;
@@ -9,10 +10,10 @@ function expectKnownEndpoints(api) {
   expect(api.inventory.trips).to.exist;
 }
 
-describe("client", function() {
-  const baseURL = "http://someUrl.com"
+describe("client", () => {
+  const baseURL = "http://someUrl.com";
 
-  it("should create a client with production values if no default provided", function() {
+  it("should create a client with production values if no default provided", () => {
     const api = createApiClient();
 
     expectKnownEndpoints(api);
@@ -20,8 +21,8 @@ describe("client", function() {
     expect(api.inventory.__test.client.defaults.timeout).to.eql(15000);
   });
 
-  it("should create a client with default values", function() {
-    const api = createApiClient({ baseURL });
+  it("should create a client with default values", () => {
+    const api = createApiClient({baseURL});
 
     expectKnownEndpoints(api);
     expect(api.inventory.__test.client.defaults.baseURL).to.eql(baseURL);
@@ -32,19 +33,29 @@ describe("client", function() {
     const api = createApiClient({headers: {"x-test-header": "some_value"}});
 
     const ignoredApiProperties = ["constants", "_cleanClient"];
-    const propertyIsRelevant = (property) => !ignoredApiProperties.includes(property);
+    function propertyIsRelevant(property) {
+      return !ignoredApiProperties.includes(property);
+    }
     for (const subsystem of Object.keys(api).filter(propertyIsRelevant)) {
       expect(api[subsystem].__test.client.defaults.headers).to.include({"x-test-header": "some_value"});
     }
   });
 
   it("should expose a INTERNAL_AUTH_TOKEN constant", () => {
-    const api = createApiClient({ baseURL });
+    const api = createApiClient({baseURL});
     expect(api.constants.INTERNAL_AUTH_TOKEN_SYMBOL).to.be.eql("internal_auth_token");
   });
 
-  it("should allow to override baseUrl for custom endpoints", function() {
-    const api = createApiClient({ baseURL, timeout: 10, baseURLOverride: { inventory: (url) => `${url}/somePath` } });
+  it("should allow to override baseUrl for custom endpoints", () => {
+    const api = createApiClient({
+      baseURL,
+      timeout: 10,
+      baseURLOverride: {
+        inventory: (url) => {
+          return `${url}/somePath`;
+        }
+      }
+    });
     expect(api.inventory.products).to.exist;
     expect(api.inventory.insurances).to.exist;
 
@@ -54,18 +65,22 @@ describe("client", function() {
   });
 
   it("should allow a different baseUrl to be specified for trip search endpoints", () => {
-    const api = createApiClient({ baseURL, timeout: 10, baseURLOverride: {
-      inventory: () => "http://localhost:3010/inventory",
-      trips: () => "http://localhost:3090/inventory"
-    } });
+    const api = createApiClient({
+      baseURL,
+      timeout: 10,
+      baseURLOverride: {
+        inventory: () => { return "http://localhost:3010/inventory"; },
+        trips: () => { return "http://localhost:3090/inventory"; }
+      }
+    });
 
     expectKnownEndpoints(api);
     expect(api.inventory.__test.client.defaults.baseURL).to.eql("http://localhost:3010/inventory");
     expect(api.inventory.__test_trips.client.defaults.baseURL).to.eql("http://localhost:3090/inventory");
   });
 
-  it("should allow to perform custom request on clean client", function() {
-    const api = createApiClient({ baseURL, timeout: 0 });
+  it("should allow to perform custom request on clean client", () => {
+    const api = createApiClient({baseURL, timeout: 0});
     expect(api.inventory.products).to.exist;
     expect(api.inventory.insurances).to.exist;
 
@@ -73,12 +88,132 @@ describe("client", function() {
     expect(api._cleanClient.defaults.baseURL).to.eql(baseURL);
     expect(api._cleanClient.defaults.timeout).to.eql(0);
 
-    const mock =  new MockAdapter(api._cleanClient);
-    mock.onPost(`/custom/endpoint`).reply(200);
-    const promise = api._cleanClient({ url: '/custom/endpoint', method: 'post' });
+    const mock = new MockAdapter(api._cleanClient);
+    mock.onPost("/custom/endpoint").reply(200);
+    const promise = api._cleanClient({url: "/custom/endpoint", method: "post"});
 
     mock.restore();
     return promise;
   });
 
-})
+  describe("http networking", () => {
+    describe("with keepAlive enabled in a custom endpoint", () => {
+      let mockServer = null;
+
+      before((done) => {
+        axiosMock.restore();
+        mockServer = createTestServer({
+          host: "localhost",
+          port: 8888,
+          maxSockets: 10
+        }, (req) => {
+          expect(req.headers.connection).to.equal("keep-alive");
+        });
+        mockServer.create((err) => {
+          if (err) return done(err);
+          return done();
+        });
+      });
+
+      after((done) => {
+        mockServer.close(() => {
+          done();
+        });
+      });
+
+      it("should only use the max sockets available to perform 100 concurrent requests", async () => {
+        const http = require("http");
+        const https = require("https");
+
+        const agents = {
+          httpAgent: new http.Agent({keepAlive: true, maxSockets: 10}),
+          httpsAgent: new https.Agent({keepAlive: true})
+        };
+        const api = createApiClient({baseURL: "http://localhost:8888", timeout: 0, agents});
+        const mock = new MockAdapter(api._cleanClient);
+        mock.restore();
+        const promises = new Array(100).fill().map((i) => {
+          return api._cleanClient({url: `/test/${i}`, method: "get"});
+        });
+        return Promise.all(promises);
+      });
+    });
+
+    describe("with keepAlive enabled in a known endpoint", () => {
+      let mockServer = null;
+
+      before((done) => {
+        axiosMock.restore();
+        mockServer = createTestServer({
+          host: "localhost",
+          port: 8888,
+          maxSockets: 10
+        }, (req) => {
+          expect(req.headers.connection).to.equal("keep-alive");
+        });
+        mockServer.create((err) => {
+          if (err) return done(err);
+          return done();
+        });
+      });
+
+      after((done) => {
+        mockServer.close(() => {
+          done();
+        });
+      });
+
+      it("should use at least 10 sockets to perform 100 concurrent product requests", async () => {
+        const http = require("http");
+        const https = require("https");
+
+        const agents = {
+          httpAgent: new http.Agent({keepAlive: true, maxSockets: 10}),
+          httpsAgent: new https.Agent({keepAlive: true})
+        };
+        const api = createApiClient({baseURL: "http://localhost:8888", timeout: 0, agents});
+        const mock = new MockAdapter(api._cleanClient);
+        mock.restore();
+        const promises = new Array(100).fill().map(() => {
+          return api.inventory.products.all({token: "I owe you a token"});
+        });
+        return Promise.all(promises);
+      });
+    });
+
+    describe("with keepAlive disabled (default)", () => {
+      let mockServer = null;
+
+      before((done) => {
+        axiosMock.restore();
+        mockServer = createTestServer({
+          host: "localhost",
+          port: 8888,
+          maxSockets: 100
+        }, (req) => {
+          expect(req.headers.connection).to.equal("close");
+        });
+        mockServer.create((err) => {
+          if (err) return done(err);
+          return done();
+        });
+      });
+
+      after((done) => {
+        mockServer.close(() => {
+          done();
+        });
+      });
+
+      it("should socket no more than 100 sockets to perform 100 concurrent requests", async () => {
+        const api = createApiClient({baseURL: "http://localhost:8888", timeout: 0});
+        const mock = new MockAdapter(api._cleanClient);
+        mock.restore();
+        const promises = new Array(100).fill().map((i) => {
+          return api._cleanClient({url: `/test/${i}`, method: "get"});
+        });
+        return Promise.all(promises);
+      });
+    });
+  });
+});

package/test/endpoints/gps/scanner-app-location.js

@@ -0,0 +1,26 @@
+const {axiosMock, expectRequest} = require("./../../test-helpers.js");
+const api = require("./../../../src/client.js")
+  .createApiClient({baseURL: "http://test.com"});
+
+describe("gps/scanner-app-location", () => {
+  const apiKey = "yourAccountAPIKey";
+
+  afterEach(() => {
+    axiosMock.reset();
+  });
+
+  it("should GET a location", () => {
+    const routeId = "myRoute";
+    const scheduleId = "myScheduleId";
+    const date = "2020-01-01";
+    const includeTravelledPath = true;
+    const query = {
+      routeId,
+      scheduleId,
+      date,
+      includeTravelledPath
+    };
+    axiosMock.onGet("/scanner-app-location").reply(expectRequest({statusCode: 200, token: apiKey}));
+    return api.gps.scannerAppLocation.get({token: apiKey, query});
+  });
+});

package/test/test-helpers.js

@@ -1,5 +1,7 @@
-const axios = require('axios');
-const MockAdapter = require('axios-mock-adapter');
+const axios = require("axios");
+const MockAdapter = require("axios-mock-adapter");
+const http = require("http");
+const {expect} = require("chai");
 
 module.exports = {
   axiosMock: new MockAdapter(axios),
@@ -22,5 +24,37 @@ module.exports = {
       }
       return [403];
     };
+  },
+  createTestServer: (config = {}, reqCallback = () => {}) => {
+    const sockets = new Set();
+    const mockServer = http.createServer((req, res) => {
+      reqCallback(req, res);
+      res.writeHead(200, {"Content-Type": "text/plain"});
+      res.end("OK");
+    });
+
+    mockServer.on("connection", (socket) => {
+      sockets.add(socket);
+      if (config.maxSockets) {
+        expect(sockets.size).to.be.lessThanOrEqual(config.maxSockets);
+      }
+    });
+
+    return {
+      create: (callback) => {
+        mockServer.listen(config.port || 8888, config.host || "localhost", callback);
+      },
+      getSockets: () => {
+        return sockets.size;
+      },
+      close: (callback) => {
+        for (const socket of sockets) {
+          socket.destroy();
+          sockets.delete(socket);
+        }
+        sockets.clear();
+        mockServer.close(callback);
+      }
+    };
   }
 };