btrz-api-client 8.65.0 → 8.66.1

package/test-integration/endpoints/accounts/lexicons.test.js

@@ -1,5 +1,5 @@
-const {expect} = require("chai");
-const uuid = require("uuid");
+const assert = require("node:assert/strict");
+const {randomUUID} = require("node:crypto");
 
 const port = process.env.ACCOUNTS_API_PORT;
 const token = process.env.API_TOKEN;
@@ -7,56 +7,61 @@ const jwtToken = process.env.JWT_TOKEN;
 const accountId = process.env.ACCOUNT_ID;
 const existingLexiconKey = process.env.EXISTING_LEXICON_KEY;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    accounts: (baseUrl) => `${baseUrl}/accounts`
+    accounts: (baseUrl) => { return `${baseUrl}/accounts`; }
   }
 });
 
-const { matchHeaders, statusCode } = require("./../../test-integration-helpers");
+const {matchHeaders, statusCode} = require("./../../test-integration-helpers.js");
 
-describe("accounts/lexicons", function() {
-
-  it("should list lexicons", function() {
-    return api.accounts.lexicons.all({ token, context: "vue" })
-      .then(matchHeaders('x-api-key'))
-      .then(statusCode(200))
+describe("accounts/lexicons", () => {
+  it("should list lexicons", () => {
+    return api.accounts.lexicons.all({token, context: "vue"})
+      .then(matchHeaders("x-api-key"))
+      .then(statusCode(200));
   });
 
-  it("should create lexicon entries", function() {
-    return api.accounts.lexicons.create({ token, jwtToken, lexiconEntries: [{
-          accountId,
-          name: "test-lexicon-entry-1",
-          context: ["app", "websales", "vue"],
-          values: {
-            "en-us": "Test lexicon entry",
-            "fr-fr": "Test lexicon entry french"
-          }
-        }]
-      })
+  it("should create lexicon entries", () => {
+    return api.accounts.lexicons.create({
+      token,
+      jwtToken,
+      lexiconEntries: [{
+        accountId,
+        name: "test-lexicon-entry-1",
+        context: ["app", "websales", "vue"],
+        values: {
+          "en-us": "Test lexicon entry",
+          "fr-fr": "Test lexicon entry french"
+        }
+      }]
+    })
       .then(({status, data}) => {
-        expect(status).to.equal(200);
-        expect(data.successes).to.have.length(1);
-        expect(data.failures).to.have.length(0);
+        assert.deepStrictEqual(status, 200);
+        assert.strictEqual(data.successes.length, 1);
+        assert.strictEqual(data.failures.length, 0);
       });
   });
 
-  it("should update lexicon entries", function () {
-    const newTranslation = uuid.v4();
+  it("should update lexicon entries", () => {
+    const newTranslation = randomUUID();
 
-    return api.accounts.lexicons.updateMany({ token, jwtToken, updates: [{
+    return api.accounts.lexicons.updateMany({
+      token,
+      jwtToken,
+      updates: [{
         accountId,
         key: existingLexiconKey,
         values: {
           "en-us": newTranslation
         }
-      }]})
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.entries).to.have.length(1);
-      expect(data.entries[0].values["en-us"]).to.eql(newTranslation);
-    });
+      }]
+    })
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.strictEqual(data.entries.length, 1);
+        assert.deepStrictEqual(data.entries[0].values["en-us"], newTranslation);
+      });
   });
-
-});
+});

package/test-integration/endpoints/accounts/shifts.test.js

@@ -1,20 +1,17 @@
 const port = process.env.ACCOUNTS_API_PORT;
 const token = process.env.API_TOKEN;
 
-const api = require("./../../../src/client").createApiClient({ 
-  baseURL: `http://localhost:${port}`, 
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    accounts: (baseUrl) => `${baseUrl}/accounts`
+    accounts: (baseUrl) => { return `${baseUrl}/accounts`; }
   }
 });
 
-const { matchHeaders, statusCode } = require("./../../test-integration-helpers");
 
 describe("accounts/shift/user", () => {
-
   it.skip("should get the shift of the user specified", () => {
     const userId = "5818b94537e32ee60c000005";
-    return api.accounts.shifts.get({ token, userId });
+    return api.accounts.shifts.get({token, userId});
   });
-
-});
+});

package/test-integration/endpoints/accounts/users.test.js

@@ -1,12 +1,12 @@
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 const port = process.env.ACCOUNTS_API_PORT;
 const token = process.env.API_TOKEN;
 const id = "5818b94537e32ee60c000005";
 
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    accounts: (baseUrl) => `${baseUrl}/accounts`
+    accounts: (baseUrl) => { return `${baseUrl}/accounts`; }
   }
 });
 
@@ -14,7 +14,7 @@ describe("accounts/user/{id}", () => {
   it("should return user", () => {
     return api.accounts.users.get({token, id})
       .then((res) => {
-        expect(res.status).to.be.eql(200);
+        assert.deepStrictEqual(res.status, 200);
       });
   });
 });

package/test-integration/endpoints/btrzpay/customerCards.test.js

@@ -1,4 +1,4 @@
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 const port = process.env.BTRZPAY_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
@@ -6,15 +6,15 @@ const customerId = process.env.CUSTOMER_ID;
 const customerCardId = process.env.CUSTOMER_CARD_ID;
 const paymentMethodId = process.env.PAYMENT_METHOD_ID;
 const providerPaymentProfileId = process.env.PROVIDER_PAYMENT_PROFILE_ID;
-const api = require("../../../src/client").createApiClient({
+const api = require("../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    btrzpay: (baseUrl) => `${baseUrl}/btrz-pay`
+    btrzpay: (baseUrl) => { return `${baseUrl}/btrz-pay`; }
   }
 });
 
-describe("btrz-pay/payment-methods/${paymentMethodId}/customers/${customerId}/customerCards", () => {
-  it("should create a customer card", (done) => {
+describe(`btrz-pay/payment-methods/${paymentMethodId}/customers/${customerId}/customerCards`, () => {
+  it("should create a customer card", async () => {
     const customerCard = {
       customerId,
       providerPaymentProfileId,
@@ -25,77 +25,53 @@ describe("btrz-pay/payment-methods/${paymentMethodId}/customers/${customerId}/cu
       isDefault: true
     };
 
-    return api.btrzpay.customerCards.create({
+    const {status, data} = await api.btrzpay.customerCards.create({
       jwtToken,
       token,
       paymentMethodId,
       customerId,
       customerCard
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.customerId).to.eql(customerCard.customerId);
-      expect(data.paymentMethodId).to.eql(paymentMethodId);
-      expect(data.id).to.exist;
-      done();
-    })
-    .catch((err)=> {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.customerId, customerCard.customerId);
+    assert.deepStrictEqual(data.paymentMethodId, paymentMethodId);
+    assert.ok(data.id);
   });
 
-  it("should get a customer card", (done) => {
-    return api.btrzpay.customerCards.get({
+  it("should get a customer card", async () => {
+    const {status, data} = await api.btrzpay.customerCards.get({
       jwtToken,
       token,
       paymentMethodId,
       customerId,
       customerCardId
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.customerCard.id).to.eql(customerCardId);
-      expect(data.customerCard.providerPaymentProfileId).to.eql(providerPaymentProfileId);
-      expect(data.customerCard.id).to.exist;
-      done();
-    })
-    .catch((err) => {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.customerCard.id, customerCardId);
+    assert.deepStrictEqual(data.customerCard.providerPaymentProfileId, providerPaymentProfileId);
+    assert.ok(data.customerCard.id);
   });
 
-  it("should get all customer cards", (done) => {
-    return api.btrzpay.customerCards.all({
+  it("should get all customer cards", async () => {
+    const {status, data} = await api.btrzpay.customerCards.all({
       jwtToken,
       token,
       paymentMethodId,
       customerId
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.customerCards.length).to.eql(2);
-      done();
-    })
-    .catch((err) => {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.customerCards.length, 2);
   });
 
-  it("should delete a customer card", (done) => {
-    return api.btrzpay.customerCards.remove({
+  it("should delete a customer card", async () => {
+    const {status, data} = await api.btrzpay.customerCards.remove({
       jwtToken,
       token,
       paymentMethodId,
       customerId,
       customerCardId
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.result).to.eql(1);
-      done();
-    })
-    .catch((err)=> {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.result, 1);
   });
 });

package/test-integration/endpoints/btrzpay/customers.test.js

@@ -1,72 +1,58 @@
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 const port = process.env.BTRZPAY_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 const customerId = process.env.CUSTOMER_ID;
 const paymentMethodId = process.env.PAYMENT_METHOD_ID;
 const providerCustomerProfileId = process.env.PROVIDER_CUSTOMER_PROFILE_ID;
-const api = require("../../../src/client").createApiClient({
+const api = require("../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
-    btrzpay: (baseUrl) => `${baseUrl}/btrz-pay`
+    btrzpay: (baseUrl) => {
+      return `${baseUrl}/btrz-pay`;
+    }
   }
 });
 
+// eslint-disable-next-line no-template-curly-in-string
 describe("btrz-pay/payment-methods/${paymentMethodId}/customers", () => {
-  it("should create a customer", (done) => {
+  it("should create a customer", async () => {
     const customer = {
       customerId,
       providerCustomerProfileId
     };
 
-    return api.btrzpay.customers.create({
+    const {status, data} = await api.btrzpay.customers.create({
       jwtToken,
       token,
       paymentMethodId,
       customer
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.customerId).to.eql(customer.customerId);
-      expect(data.paymentMethodId).to.eql(paymentMethodId);
-      expect(data.providerCustomerProfileId).to.exist;
-      done();
-    })
-    .catch((err)=> {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.customerId, customer.customerId);
+    assert.deepStrictEqual(data.paymentMethodId, paymentMethodId);
+    assert.ok(data.providerCustomerProfileId);
   });
 
-  it("should get a customer", () => {
-    return api.btrzpay.customers.get({
+  it("should get a customer", async () => {
+    const {status, data} = await api.btrzpay.customers.get({
       jwtToken,
       token,
       paymentMethodId,
       customerId
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.customer.customerId).to.eql(customerId);
-      done();
-    })
-    .catch((err)=> {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.customer.customerId, customerId);
   });
 
-  it("should delete a customer", () => {
-    return api.btrzpay.customers.remove({
+  it("should delete a customer", async () => {
+    const {status, data} = await api.btrzpay.customers.remove({
       jwtToken,
       token,
       paymentMethodId,
       customerId
-    })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.result).to.eql(1);
-    })
-    .catch((err)=> {
-      done(err);
     });
+    assert.deepStrictEqual(status, 200);
+    assert.deepStrictEqual(data.result, 1);
   });
 });

package/test-integration/endpoints/btrzpay/payment-methods.test.js

@@ -1,23 +1,23 @@
-const { expect } = require("chai"),
-  port = process.env.BTRZPAY_API_PORT,
-  token = process.env.API_TOKEN,
-  jwtToken = process.env.JWT_TOKEN,
-  paymentMethodId = process.env.PAYMENT_METHOD_ID,
-  providerAccountId = process.env.PROVIDER_ACCOUNT_ID,
-  api = require("./../../../src/client").createApiClient({
-    baseURL: `http://localhost:${port}`,
-    baseURLOverride: {
-      btrzpay: (baseUrl) => `${baseUrl}/btrz-pay`
-    }
-  });
+const assert = require("node:assert/strict");
+const port = process.env.BTRZPAY_API_PORT;
+const token = process.env.API_TOKEN;
+const jwtToken = process.env.JWT_TOKEN;
+const paymentMethodId = process.env.PAYMENT_METHOD_ID;
+const providerAccountId = process.env.PROVIDER_ACCOUNT_ID;
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
+  baseURLOverride: {
+    btrzpay: (baseUrl) => { return `${baseUrl}/btrz-pay`; }
+  }
+});
 
-describe("btrz-pay/payment-methods", function() {
-  it("should return empty success", function() {
+describe("btrz-pay/payment-methods", () => {
+  it("should return empty success", () => {
     const providerName = "anyName";
-    return api.btrzpay.paymentMethods.getByProviderName({ token, jwtToken, providerName })
+    return api.btrzpay.paymentMethods.getByProviderName({token, jwtToken, providerName})
       .then((result) => {
-        expect(result.status).to.be.eql(200);
-        expect(result.data.paymentMethods).to.be.eql([]);
+        assert.deepStrictEqual(result.status, 200);
+        assert.deepStrictEqual(result.data.paymentMethods, []);
       });
   });
 
@@ -34,13 +34,13 @@ describe("btrz-pay/payment-methods", function() {
       token,
       paymentMethod
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.paymentMethod.method).to.eql(paymentMethod.method);
-      expect(data.paymentMethod.displayName).to.eql(paymentMethod.displayName);
-      expect(data.paymentMethod.ord).to.eql(paymentMethod.ord);
-      expect(data.paymentMethod.provider).to.eql(paymentMethod.providerName);
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.paymentMethod.method, paymentMethod.method);
+        assert.deepStrictEqual(data.paymentMethod.displayName, paymentMethod.displayName);
+        assert.deepStrictEqual(data.paymentMethod.ord, paymentMethod.ord);
+        assert.deepStrictEqual(data.paymentMethod.provider, paymentMethod.providerName);
+      });
   });
 
   it("should get a payment method", () => {
@@ -49,10 +49,10 @@ describe("btrz-pay/payment-methods", function() {
       token,
       paymentMethodId
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.paymentMethod._id).to.eql(paymentMethodId);
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.paymentMethod._id, paymentMethodId);
+      });
   });
 
   it("should get a payment method with providerId in query (Agency)", () => {
@@ -62,10 +62,10 @@ describe("btrz-pay/payment-methods", function() {
       paymentMethodId,
       query: {providerId: providerAccountId}
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.paymentMethod._id).to.eql(paymentMethodId);
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.paymentMethod._id, paymentMethodId);
+      });
   });
 
   it("should update a payment method", () => {
@@ -80,8 +80,8 @@ describe("btrz-pay/payment-methods", function() {
       }
     })
       .then(({status, data}) => {
-        expect(status).to.equal(200);
-        expect(data.updated).to.be.eql(true);
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.updated, true);
       });
   });
 });

package/test-integration/endpoints/btrzpay/payments.test.js

@@ -1,14 +1,14 @@
-const { expect } = require("chai"),
-  port = process.env.BTRZPAY_API_PORT,
-  token = process.env.API_TOKEN,
-  jwtToken = process.env.JWT_TOKEN,
-  transactionId = process.env.TRANSACTION_ID,
-  api = require("./../../../src/client").createApiClient({
-    baseURL: `http://localhost:${port}`,
-    baseURLOverride: {
-      btrzpay: (baseUrl) => `${baseUrl}/btrz-pay`
-    }
-  });
+const assert = require("node:assert/strict");
+const port = process.env.BTRZPAY_API_PORT;
+const token = process.env.API_TOKEN;
+const jwtToken = process.env.JWT_TOKEN;
+const transactionId = process.env.TRANSACTION_ID;
+const api = require("./../../../src/client.js").createApiClient({
+  baseURL: `http://localhost:${port}`,
+  baseURLOverride: {
+    btrzpay: (baseUrl) => { return `${baseUrl}/btrz-pay`; }
+  }
+});
 
 describe("btrz-pay/payments", () => {
   it("should create a payment method", () => {
@@ -27,12 +27,12 @@ describe("btrz-pay/payments", () => {
       token,
       payments
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.payments[0].transactionId).to.eql(payments.items[0].transactionId);
-      expect(data.payments[0].status).to.eql("pending");
-      expect(data.payments[0].result).to.eql("{}");
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.payments[0].transactionId, payments.items[0].transactionId);
+        assert.deepStrictEqual(data.payments[0].status, "pending");
+        assert.deepStrictEqual(data.payments[0].result, "{}");
+      });
   });
 
   it("should get the payments for the transaction Id", () => {
@@ -41,9 +41,9 @@ describe("btrz-pay/payments", () => {
       token,
       transactionId
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.payments[0].transactionId).to.eql(transactionId);
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.payments[0].transactionId, transactionId);
+      });
   });
 });

package/test-integration/endpoints/btrzpay/reference-numbers.test.js

@@ -1,15 +1,15 @@
-const { expect } = require("chai"),
-  port = process.env.BTRZPAY_API_PORT,
-  token = process.env.API_TOKEN,
-  jwtToken = process.env.JWT_TOKEN,
-  api = require("./../../../src/client").createApiClient({
-    baseURL: `http://localhost:${port}`,
-    baseURLOverride: {
-      btrzpay: (baseUrl) => `${baseUrl}/btrz-pay`
-    }
-  });
+const assert = require("node:assert/strict");
+const port = process.env.BTRZPAY_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: {
+    btrzpay: (baseUrl) => { return `${baseUrl}/btrz-pay`; }
+  }
+});
 
-describe("btrz-pay/reference-numbers", function() {
+describe("btrz-pay/reference-numbers", () => {
   it("should create a reference number", () => {
     const referenceNumberRequest = {
       "type": "pay_me_later",
@@ -28,9 +28,9 @@ describe("btrz-pay/reference-numbers", function() {
       token,
       referenceNumberRequest
     })
-    .then(({status, data}) => {
-      expect(status).to.equal(200);
-      expect(data.referenceNumber.length).to.eql(8);
-    });
+      .then(({status, data}) => {
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.referenceNumber.length, 8);
+      });
   });
 });

package/test-integration/endpoints/btrzpay/referenced-payments.test.js

@@ -1,11 +1,11 @@
-const {expect} = require("chai");
+const assert = require("node:assert/strict");
 const port = process.env.BTRZPAY_API_PORT;
 const token = process.env.API_TOKEN;
 const jwtToken = process.env.JWT_TOKEN;
 const transactionId = process.env.TRANSACTION_ID;
 const referenceNumber = process.env.REFERENCE_NUMBER;
 const externalType = process.env.EXTERNAL_TYPE;
-const api = require("./../../../src/client").createApiClient({
+const api = require("./../../../src/client.js").createApiClient({
   baseURL: `http://localhost:${port}`,
   baseURLOverride: {
     btrzpay: (baseUrl) => {
@@ -23,8 +23,8 @@ describe("btrz-pay/referenced-payments", () => {
       referenceNumber
     })
       .then(({status, data}) => {
-        expect(status).to.equal(200);
-        expect(data.paymentResult).to.eql(null);
+        assert.deepStrictEqual(status, 200);
+        assert.deepStrictEqual(data.paymentResult, null);
       });
   });
 
@@ -42,7 +42,7 @@ describe("btrz-pay/referenced-payments", () => {
       }
     })
       .then(({status}) => {
-        expect(status).to.equal(200);
+        assert.deepStrictEqual(status, 200);
       });
   });
 });

package/test-integration/endpoints/client.test.js

@@ -1,17 +1,13 @@
 const port = process.env.INVENTORY_API_PORT;
 const token = process.env.API_TOKEN;
 
-const api = require("./../../src/client").createApiClient({ baseURL: `http://localhost:${port}`, });
+const api = require("./../../src/client.js").createApiClient({baseURL: `http://localhost:${port}`});
 
-const { matchHeaders } = require("./../test-integration-helpers");
+const {matchHeaders} = require("./../test-integration-helpers.js");
 
-describe("clean client", function() {
-
-  it("should list products using clean client", function() {
-    return api._cleanClient({ url: `/inventory/products`, headers: { 'x-api-key': token }, params: { isParcel: true } })
-      .then(matchHeaders('x-api-key'))
+describe("clean client", () => {
+  it("should list products using clean client", () => {
+    return api._cleanClient({url: "/inventory/products", headers: {"x-api-key": token}, params: {isParcel: true}})
+      .then(matchHeaders("x-api-key"));
   });
-
 });
-  
-