btrz-api-client 8.65.0 → 8.66.1

package/test-integration/endpoints/notifications/printed-tickets.test.js

@@ -2,10 +2,10 @@ const port = process.env.NOTIFICATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    notifications: (baseUrl) => `${baseUrl}/notifications`
+    notifications: (baseUrl) => { return `${baseUrl}/notifications`; }
   }
 });
 

package/test-integration/endpoints/operations/applied_insurance.test.js

@@ -1,24 +1,22 @@
-const { expect } = require("chai");
+const assert = require("node:assert/strict");
 
 const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/appliedInsurances", function() {
-
-  it("empty array for unexistent transaction", function() {
+describe("operations/appliedInsurances", () => {
+  it("empty array for unexistent transaction", () => {
     const trxId = "NOT_EXISTING_TRX";
-    return api.operations.appliedInsurance.all({ token, jwtToken, trxId })
+    return api.operations.appliedInsurance.all({token, jwtToken, trxId})
       .then((res) => {
-        expect(res.data.appliedInsurances).to.have.lengthOf(0);
-      })
+        assert.strictEqual(res.data.appliedInsurances.length, 0);
+      });
   });
-
 });

package/test-integration/endpoints/operations/manifest.test.js

@@ -1,34 +1,33 @@
-const { expect } = require("chai");
+const assert = require("node:assert/strict");
 
 const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/manifest", function() {
-
-  it("should not get a manifest that does not exist", function() {
+describe("operations/manifest", () => {
+  it("should not get a manifest that does not exist", () => {
     const query = {routeId: "51ed2be3cf2c819d00000000", scheduleId: "Morning", date: "2017-08-21"};
-    return api.operations.manifest.get({ token, jwtToken, query })
+    return api.operations.manifest.get({token, jwtToken, query})
       .catch((err) => {
-        expect(err).to.exist;
-        expect(err.response.status).to.be.eql(404);
-        expect(err.response.data.code).to.be.eql('MANIFEST_NOT_FOUND');
-        expect(err.response.data.message).to.be.eql('manifest not found');
+        assert.ok(err);
+        assert.deepStrictEqual(err.response.status, 404);
+        assert.deepStrictEqual(err.response.data.code, "MANIFEST_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.message, "manifest not found");
       });
   });
 
-  it("should get the manifest", function() {
+  it("should get the manifest", () => {
     const query = {routeId: "51ed2be3cf2c819d5e000010", scheduleId: "Morning", date: "2017-08-21"};
-    return api.operations.manifest.get({ token, jwtToken, query })
+    return api.operations.manifest.get({token, jwtToken, query})
       .then((res) => {
-        expect(res.data.manifest._id).to.be.eql("5997315d8efff74052000005");
+        assert.deepStrictEqual(res.data.manifest._id, "5997315d8efff74052000005");
       });
   });
 
@@ -45,30 +44,29 @@ describe("operations/manifest", function() {
         date: "2020-01-14"
       }]
     };
-    const {data: response} = await api.operations.manifest.getMany({ token, jwtToken, providerId, data: payload });
-    expect(response).to.be.an.array;
-    expect(response).to.have.length(2);
+    const {data: response} = await api.operations.manifest.getMany({token, jwtToken, providerId, data: payload});
+    assert.ok(Array.isArray(response));
+    assert.strictEqual(response.length, 2);
 
-    //TODO: These expectations probably fail even on a successful response.  Edit these once the POST /manifests endpoint is complete.
-    expect(response[0].routeId).to.eql("5c50e32e62da38d275000001");
-    expect(response[0].schedule).to.eql("ef83faaa-b58f-43bb-8c5c-92e2bfa476c0");
-    //TODO: Particularly the date format is probably incorrect
-    expect(response[0].date).to.eql("2019-02-27");
+    // Note: These expectations probably fail even on a successful response.  Edit these once the POST /manifests endpoint is complete.
+    assert.deepStrictEqual(response[0].routeId, "5c50e32e62da38d275000001");
+    assert.deepStrictEqual(response[0].schedule, "ef83faaa-b58f-43bb-8c5c-92e2bfa476c0");
+    // Note: Particularly the date format is probably incorrect
+    assert.deepStrictEqual(response[0].date, "2019-02-27");
 
-    expect(response[0].routeId).to.eql("528cdd9c61c78c2f2d000066");
-    expect(response[0].schedule).to.eql("711-b58f-43bb-8c5c-92e2bfa476c0");
-    expect(response[0].date).to.eql("2020-01-14");
+    assert.deepStrictEqual(response[0].routeId, "528cdd9c61c78c2f2d000066");
+    assert.deepStrictEqual(response[0].schedule, "711-b58f-43bb-8c5c-92e2bfa476c0");
+    assert.deepStrictEqual(response[0].date, "2020-01-14");
   });
 
-  it("should patch a manifest with add_tickets operation", function() {
-    const providerId = "5997315d8efff74052000005",
-      operations = [{op: "add_tickets", tickets: ["576989208f86028739fef256"]}];
-    return api.operations.manifest.patch({ token, jwtToken, query: {providerId}, operations })
+  it("should patch a manifest with add_tickets operation", () => {
+    const providerId = "5997315d8efff74052000005";
+    const operations = [{op: "add_tickets", tickets: ["576989208f86028739fef256"]}];
+    return api.operations.manifest.patch({token, jwtToken, query: {providerId}, operations})
       .then((res) => {
-        expect(res.data.results).to.have.length(1);
-        expect(res.data.results[0].op).to.be.eql("add_tickets");
-        expect(res.data.results[0].status).to.be.eql("success");
+        assert.strictEqual(res.data.results.length, 1);
+        assert.deepStrictEqual(res.data.results[0].op, "add_tickets");
+        assert.deepStrictEqual(res.data.results[0].status, "success");
       });
   });
-
 });

package/test-integration/endpoints/operations/parcel.test.js

@@ -1,62 +1,60 @@
-const { expect } = require("chai");
+const assert = require("node:assert/strict");
 
 const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/parcel", function() {
-
-  it("should not get a parcel that does not exist", function() {
+describe("operations/parcel", () => {
+  it("should not get a parcel that does not exist", () => {
     const parcelId = "5967e3da1b7dfb3047e5ac81";
-    return api.operations.parcel.get({ token, jwtToken, id: parcelId })
+    return api.operations.parcel.get({token, jwtToken, id: parcelId})
       .catch((err) => {
-        expect(err).to.exist;
-        expect(err.response.status).to.be.eql(404);
-        expect(err.response.data.code).to.be.eql('PARCEL_NOT_FOUND');
-        expect(err.response.data.message).to.be.eql('Parcel not found');
-      })
+        assert.ok(err);
+        assert.deepStrictEqual(err.response.status, 404);
+        assert.deepStrictEqual(err.response.data.code, "PARCEL_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.message, "Parcel not found");
+      });
   });
 
-  it("should not get any parcel from a trx that does not exist", function() {
+  it("should not get any parcel from a trx that does not exist", () => {
     const trxId = "5967e3da1b7dfb3047e5ac81";
-    return api.operations.parcel.all({ token, jwtToken, query: {trxId: trxId }})
+    return api.operations.parcel.all({token, jwtToken, query: {trxId}})
       .catch((err) => {
-        expect(err).to.exist;
-        expect(err.response.status).to.be.eql(401);
-        expect(err.response.data.code).to.be.eql('PARCEL_NOT_FOUND');
-        expect(err.response.data.message).to.be.eql('Parcel not found');
-      })
+        assert.ok(err);
+        assert.deepStrictEqual(err.response.status, 401);
+        assert.deepStrictEqual(err.response.data.code, "PARCEL_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.message, "Parcel not found");
+      });
   });
 
-  it("should not update parcel that not exists", function() {
-    const parcelId = "596e33cea74c7dd74c2f8572",
-      parcel = {_id: parcelId, status: "delivered"},
-      locationData = {latitude: 9876, longitude: 0123};
-    return api.operations.parcel.update({ token, jwtToken, id: parcelId, parcel, locationData })
+  it("should not update parcel that not exists", () => {
+    const parcelId = "596e33cea74c7dd74c2f8572";
+    const parcel = {_id: parcelId, status: "delivered"};
+    const locationData = {latitude: 9876, longitude: 123};
+    return api.operations.parcel.update({token, jwtToken, id: parcelId, parcel, locationData})
       .catch((err) => {
-        expect(err).to.exist;
-        expect(err.response.status).to.be.eql(404);
-        expect(err.response.data.code).to.be.eql('TICKET_NOT_FOUND');
-        expect(err.response.data.msg).to.be.eql('parcel not found for id: 596e33cea74c7dd74c2f8572');
-      })
+        assert.ok(err);
+        assert.deepStrictEqual(err.response.status, 404);
+        assert.deepStrictEqual(err.response.data.code, "TICKET_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.msg, "parcel not found for id: 596e33cea74c7dd74c2f8572");
+      });
   });
 
-  it("should not add a comment in a parcel that not exists", function() {
+  it("should not add a comment in a parcel that not exists", () => {
     const parcelId = "596e33cea74c7dd74c2f8552";
-    return api.operations.parcel.addComment({ token, jwtToken, id: parcelId, comment: "A comment" })
+    return api.operations.parcel.addComment({token, jwtToken, id: parcelId, comment: "A comment"})
       .catch((err) => {
-        expect(err).to.exist;
-        expect(err.response.status).to.be.eql(404);
-        expect(err.response.data.code).to.be.eql('PARCEL_NOT_FOUND');
-        expect(err.response.data.msg).to.be.eql('We could not found a Parcel with the given ID');
-      })
+        assert.ok(err);
+        assert.deepStrictEqual(err.response.status, 404);
+        assert.deepStrictEqual(err.response.data.code, "PARCEL_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.msg, "We could not found a Parcel with the given ID");
+      });
   });
-
 });

package/test-integration/endpoints/operations/redemption.test.js

@@ -1,19 +1,17 @@
-const { expect } = require("chai");
 
 const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/redemptions", function() {
-
-  it("should create a redemption for the parcel", function() {
+describe("operations/redemptions", () => {
+  it("should create a redemption for the parcel", () => {
     const redemption = {
       "itemCode": "PA-59e60182bc6ef25a2cfd6b6f",
       "options": {
@@ -24,12 +22,11 @@ describe("operations/redemptions", function() {
         "operationType": "received"
       },
       "redemptions": {
-          "items": [],
-          "scannedPurchases": [],
-          "externalPasses": []
+        "items": [],
+        "scannedPurchases": [],
+        "externalPasses": []
       }
     };
-    return api.operations.redemption.create({ token, jwtToken, redemption });
+    return api.operations.redemption.create({token, jwtToken, redemption});
   });
-
 });

package/test-integration/endpoints/operations/segments.js

@@ -2,20 +2,18 @@ const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/segments", function() {
-
-  it("should get segments for product and ticket", function() {
-    const productId = "595f9c7007ee12686d000033",
-      ticketId = "5bad3ef2b726b6716b9567df",
-      providerId = "595f9c7007ee12686d000032";
-    return api.operations.segments.all({ token, jwtToken, productId, ticketId, providerId });
+describe("operations/segments", () => {
+  it("should get segments for product and ticket", () => {
+    const productId = "595f9c7007ee12686d000033";
+    const ticketId = "5bad3ef2b726b6716b9567df";
+    const providerId = "595f9c7007ee12686d000032";
+    return api.operations.segments.all({token, jwtToken, productId, ticketId, providerId});
   });
-
 });

package/test-integration/endpoints/operations/tickets.test.js

@@ -2,13 +2,13 @@
 /* eslint-disable arrow-parens */
 /* eslint-disable prefer-arrow-callback */
 
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 
 const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
     operations: (baseUrl) => {
@@ -43,9 +43,9 @@ describe("operations/tickets", function () {
 
       return api.operations.tickets.patch({token, jwtToken, id, operations: [op1], warningsEnabled})
         .then((res) => {
-          expect(res.data.results).to.have.length(1);
-          expect(res.data.results[0].op).to.be.eql("move");
-          expect(res.data.results[0].status).to.be.eql("success");
+          assert.strictEqual(res.data.results.length, 1);
+          assert.deepStrictEqual(res.data.results[0].op, "move");
+          assert.deepStrictEqual(res.data.results[0].status, "success");
         });
     });
 
@@ -62,12 +62,12 @@ describe("operations/tickets", function () {
       return api.operations.tickets.patch({token, jwtToken, id, operations: [op1], warningsEnabled})
         .catch((err) => {
           /* eslint-disable-next-line no-unused-expressions */
-          expect(err).to.exist;
-          expect(err.response.status).to.be.eql(404);
-          expect(err.response.data.results).to.have.length(1);
-          expect(err.response.data.results[0].op).to.be.eql("move");
-          expect(err.response.data.results[0].status).to.be.eql("error");
-          expect(err.response.data.results[0].error.code).to.be.eql("TICKET_NOT_FOUND");
+          assert.ok(err);
+          assert.deepStrictEqual(err.response.status, 404);
+          assert.strictEqual(err.response.data.results.length, 1);
+          assert.deepStrictEqual(err.response.data.results[0].op, "move");
+          assert.deepStrictEqual(err.response.data.results[0].status, "error");
+          assert.deepStrictEqual(err.response.data.results[0].error.code, "TICKET_NOT_FOUND");
         });
     });
   });

package/test-integration/endpoints/operations/transaction.test.js

@@ -2,7 +2,7 @@ const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
     operations: (baseUrl) => {

package/test-integration/endpoints/operations/transactions.test.js

@@ -14,7 +14,7 @@ const api = require("./../../../src/client.js").createApiClient({
     }
   }
 });
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 
 describe("operations/transactions", function () {
   describe("companion", function () {
@@ -34,7 +34,7 @@ describe("operations/transactions", function () {
       const transactionId = "5ce2d7d4c16f0e5827069f13";
       return api.operations.transactions.expireAll({jwtToken, transactionId})
         .then((res) => {
-          expect(res.data.transactionIds).to.have.length(1);
+          assert.strictEqual(res.data.transactionIds.length, 1);
         });
     });
   });

package/test-integration/endpoints/operations/trip_change_info.test.js

@@ -2,23 +2,21 @@ const port = process.env.OPERATIONS_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    operations: (baseUrl) => `${baseUrl}/operations`
+    operations: (baseUrl) => { return `${baseUrl}/operations`; }
   }
 });
 
-describe("operations/trip-change-info", function() {
-
-  it("should get the trip to change info", function() {
-    const productId = "5a61f76266d8da4c4200000b",
-      params = {
-        ticketNumber: "V6H6BH",
-        lastName: "Ferraro",
-        providerId: "595f9c7007ee12686d000032"
-      };
-    return api.operations.tripChangeInfo.get({ token, jwtToken, productId, params });
+describe("operations/trip-change-info", () => {
+  it("should get the trip to change info", () => {
+    const productId = "5a61f76266d8da4c4200000b";
+    const params = {
+      ticketNumber: "V6H6BH",
+      lastName: "Ferraro",
+      providerId: "595f9c7007ee12686d000032"
+    };
+    return api.operations.tripChangeInfo.get({token, jwtToken, productId, params});
   });
-
 });

package/test-integration/endpoints/reports/custom-reports.test.js

@@ -1,16 +1,16 @@
-const { expect } = require("chai"),
-  port = process.env.REPORTS_API_PORT,
-  token = process.env.API_TOKEN,
-  jwtToken = process.env.JWT_TOKEN,
-  api = require("./../../../src/client").createApiClient({
-    baseURL: `http://localhost:${port}`,
-    baseURLOverride: {
-      reports: (baseUrl) => `${baseUrl}/reports`
-    }
-  });
+const assert = require("node:assert/strict");
+const port = process.env.REPORTS_API_PORT;
+const token = process.env.API_TOKEN;
+const jwtToken = process.env.JWT_TOKEN;
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
+  baseURLOverride: {
+    reports: (baseUrl) => { return `${baseUrl}/reports`; }
+  }
+});
 
-describe("reports/custom-report", function() {
-  it("should return 200", function() {
+describe("reports/custom-report", () => {
+  it("should return 200", () => {
     const customReport = {
       name: "customReportName",
       reportTypeId: "5a99c3055c44c49c5a000001",
@@ -48,24 +48,24 @@ describe("reports/custom-report", function() {
         prefixForFile: "greatReport"
       }
     };
-    return api.reports.customReports.create({ jwtToken, token, customReport })
-    .catch((err) => {
-      expect(err.response.status).to.be.eql(200);
-      expect(err.response.data.customReport.name).to.be.eql(customReport.name);
-    });
+    return api.reports.customReports.create({jwtToken, token, customReport})
+      .catch((err) => {
+        assert.deepStrictEqual(err.response.status, 200);
+        assert.deepStrictEqual(err.response.data.customReport.name, customReport.name);
+      });
   });
 
-  it("should not get any custom reports", function() {
+  it("should not get any custom reports", () => {
     return api.reports.customReports.all({token, jwtToken, query: {}})
       .catch((err) => {
-        expect(err.response.status).to.be.eql(401);
+        assert.deepStrictEqual(err.response.status, 401);
       });
   });
 
-  it("should not delete a custom report", function() {
+  it("should not delete a custom report", () => {
     return api.reports.customReports.remove({token, jwtToken, customReportId: "5a959a4aa7114ffd7f000001"})
       .catch((err) => {
-        expect(err.response.status).to.be.eql(401);
+        assert.deepStrictEqual(err.response.status, 401);
       });
   });
 });

package/test-integration/endpoints/reports/report-types.test.js

@@ -1,31 +1,31 @@
-const { expect } = require("chai"),
-  port = process.env.REPORTS_API_PORT,
-  token = process.env.API_TOKEN,
-  jwtToken = process.env.JWT_TOKEN,
-  api = require("./../../../src/client").createApiClient({
-    baseURL: `http://localhost:${port}`,
-    baseURLOverride: {
-      reports: (baseUrl) => `${baseUrl}/reports`
-    }
-  });
+const assert = require("node:assert/strict");
+const port = process.env.REPORTS_API_PORT;
+const token = process.env.API_TOKEN;
+const jwtToken = process.env.JWT_TOKEN;
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
+  baseURLOverride: {
+    reports: (baseUrl) => { return `${baseUrl}/reports`; }
+  }
+});
 
-describe("reports/types", function() {
-  it("should return 404 for a wrong id", function() {
+describe("reports/types", () => {
+  it("should return 404 for a wrong id", () => {
     const reportTypeId = "reportTypeId";
-    return api.reports.reportTypes.get({ token, jwtToken, id: reportTypeId })
-    .catch((err) => {
-      expect(err.response.status).to.be.eql(404);
-      expect(err.response.data.code).to.be.eql("TYPE_NOT_FOUND");
-      expect(err.response.data.message).to.be.eql("Report type not found");
-    });
+    return api.reports.reportTypes.get({token, jwtToken, id: reportTypeId})
+      .catch((err) => {
+        assert.deepStrictEqual(err.response.status, 404);
+        assert.deepStrictEqual(err.response.data.code, "TYPE_NOT_FOUND");
+        assert.deepStrictEqual(err.response.data.message, "Report type not found");
+      });
   });
 
-  it("should return empty success", function() {
+  it("should return empty success", () => {
     const reportTypeName = "reportTypeName";
-    return api.reports.reportTypes.getByName({ token, jwtToken, name: reportTypeName })
+    return api.reports.reportTypes.getByName({token, jwtToken, name: reportTypeName})
       .then((result) => {
-        expect(result.status).to.be.eql(200);
-        expect(result.data).to.be.eql([]);
+        assert.deepStrictEqual(result.status, 200);
+        assert.deepStrictEqual(result.data, []);
       });
   });
 });

package/test-integration/endpoints/sales/bundles.test.js

@@ -1,14 +1,14 @@
 const port = process.env.SALES_API_PORT;
 const token = process.env.API_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    sales: (baseUrl) => `${baseUrl}/sales`
+    sales: (baseUrl) => { return `${baseUrl}/sales`; }
   }
 });
 
-const { matchHeaders, statusCode } = require("./../../test-integration-helpers");
+const {matchHeaders, statusCode} = require("./../../test-integration-helpers.js");
 
 describe("sales/bundles", () => {
   it("should list bundles", () => {
@@ -16,8 +16,8 @@ describe("sales/bundles", () => {
       providerId: "595f9c7007ee12686d000032",
       type: "bundles"
     };
-    return api.sales.bundles.all({ token, query })
-      .then(matchHeaders('x-api-key'))
+    return api.sales.bundles.all({token, query})
+      .then(matchHeaders("x-api-key"))
       .then(statusCode(200));
   });
 });