@xenterprises/fastify-xplaid 1.0.0

package/test/xPlaid.test.js

@@ -0,0 +1,563 @@
+/**
+ * xPlaid Tests
+ *
+ * Tests for the Plaid Fastify plugin
+ */
+
+import { describe, test, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import Fastify from "fastify";
+import xPlaid, { ENVIRONMENTS, PRODUCTS, COUNTRY_CODES } from "../src/xPlaid.js";
+
+// Mock the plaid module
+const mockPlaidApi = {
+  linkTokenCreate: mock.fn(),
+  linkTokenGet: mock.fn(),
+  itemPublicTokenExchange: mock.fn(),
+  accountsGet: mock.fn(),
+  accountsBalanceGet: mock.fn(),
+  transactionsSync: mock.fn(),
+  transactionsGet: mock.fn(),
+  transactionsRefresh: mock.fn(),
+  identityGet: mock.fn(),
+  authGet: mock.fn(),
+  investmentsHoldingsGet: mock.fn(),
+  investmentsTransactionsGet: mock.fn(),
+  liabilitiesGet: mock.fn(),
+  itemGet: mock.fn(),
+  itemRemove: mock.fn(),
+  institutionsGetById: mock.fn(),
+  institutionsSearch: mock.fn(),
+  itemWebhookUpdate: mock.fn(),
+  webhookVerificationKeyGet: mock.fn(),
+};
+
+// Store original module for restoration
+let originalPlaidModule;
+
+describe("xPlaid Plugin", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+    // Reset all mocks
+    Object.values(mockPlaidApi).forEach((fn) => fn.mock.resetCalls());
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  describe("Plugin Registration", () => {
+    test("should register successfully with valid credentials", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      assert.ok(fastify.xplaid, "xplaid should exist");
+      assert.ok(fastify.xplaid.link, "xplaid.link should exist");
+      assert.ok(fastify.xplaid.accounts, "xplaid.accounts should exist");
+      assert.ok(fastify.xplaid.transactions, "xplaid.transactions should exist");
+      assert.ok(fastify.xplaid.identity, "xplaid.identity should exist");
+      assert.ok(fastify.xplaid.auth, "xplaid.auth should exist");
+      assert.ok(fastify.xplaid.investments, "xplaid.investments should exist");
+      assert.ok(fastify.xplaid.liabilities, "xplaid.liabilities should exist");
+      assert.ok(fastify.xplaid.items, "xplaid.items should exist");
+      assert.ok(fastify.xplaid.webhooks, "xplaid.webhooks should exist");
+      assert.ok(fastify.xplaid.config, "xplaid.config should exist");
+    });
+
+    test("should throw error without clientId", async () => {
+      await assert.rejects(
+        async () => {
+          await fastify.register(xPlaid, {
+            secret: "test_secret",
+            environment: "sandbox",
+          });
+          await fastify.ready();
+        },
+        { message: "xPlaid: clientId is required" }
+      );
+    });
+
+    test("should throw error without secret", async () => {
+      await assert.rejects(
+        async () => {
+          await fastify.register(xPlaid, {
+            clientId: "test_client_id",
+            environment: "sandbox",
+          });
+          await fastify.ready();
+        },
+        { message: "xPlaid: secret is required" }
+      );
+    });
+
+    test("should default invalid environment to sandbox", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "invalid",
+      });
+      await fastify.ready();
+
+      // Invalid environments should fall back to sandbox
+      assert.strictEqual(fastify.xplaid.config.environment, "sandbox");
+    });
+
+    test("should skip registration when active is false", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+        active: false,
+      });
+      await fastify.ready();
+
+      assert.ok(!fastify.xplaid, "xplaid should not exist");
+    });
+
+    test("should default to sandbox environment", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+      });
+      await fastify.ready();
+
+      assert.strictEqual(fastify.xplaid.config.environment, "sandbox");
+    });
+
+    test("should expose constants", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      assert.ok(fastify.xplaid.constants, "constants should exist");
+      assert.ok(fastify.xplaid.constants.ENVIRONMENTS, "ENVIRONMENTS should exist");
+      assert.ok(fastify.xplaid.constants.PRODUCTS, "PRODUCTS should exist");
+      assert.ok(fastify.xplaid.constants.COUNTRY_CODES, "COUNTRY_CODES should exist");
+    });
+
+    test("should mask clientId in config", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id_12345",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      assert.ok(fastify.xplaid.config.clientId.includes("***"), "clientId should be masked");
+      assert.ok(!fastify.xplaid.config.clientId.includes("test_client_id_12345"), "full clientId should not be exposed");
+    });
+  });
+
+  describe("Exported Constants", () => {
+    test("should export ENVIRONMENTS constant", () => {
+      assert.strictEqual(ENVIRONMENTS.SANDBOX, "sandbox");
+      assert.strictEqual(ENVIRONMENTS.DEVELOPMENT, "development");
+      assert.strictEqual(ENVIRONMENTS.PRODUCTION, "production");
+    });
+
+    test("should export PRODUCTS constant", () => {
+      assert.strictEqual(PRODUCTS.AUTH, "auth");
+      assert.strictEqual(PRODUCTS.TRANSACTIONS, "transactions");
+      assert.strictEqual(PRODUCTS.IDENTITY, "identity");
+      assert.strictEqual(PRODUCTS.INVESTMENTS, "investments");
+      assert.strictEqual(PRODUCTS.LIABILITIES, "liabilities");
+      assert.strictEqual(PRODUCTS.ASSETS, "assets");
+    });
+
+    test("should export COUNTRY_CODES constant", () => {
+      assert.strictEqual(COUNTRY_CODES.US, "US");
+      assert.strictEqual(COUNTRY_CODES.CA, "CA");
+      assert.strictEqual(COUNTRY_CODES.GB, "GB");
+      assert.strictEqual(COUNTRY_CODES.IE, "IE");
+      assert.strictEqual(COUNTRY_CODES.FR, "FR");
+      assert.strictEqual(COUNTRY_CODES.ES, "ES");
+      assert.strictEqual(COUNTRY_CODES.NL, "NL");
+    });
+  });
+
+  describe("Plugin Constants", () => {
+    test("should expose ENVIRONMENTS in plugin", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      const { ENVIRONMENTS } = fastify.xplaid.constants;
+      assert.strictEqual(ENVIRONMENTS.SANDBOX, "sandbox");
+      assert.strictEqual(ENVIRONMENTS.DEVELOPMENT, "development");
+      assert.strictEqual(ENVIRONMENTS.PRODUCTION, "production");
+    });
+
+    test("should expose PRODUCTS in plugin", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      const { PRODUCTS } = fastify.xplaid.constants;
+      assert.strictEqual(PRODUCTS.AUTH, "auth");
+      assert.strictEqual(PRODUCTS.TRANSACTIONS, "transactions");
+      assert.strictEqual(PRODUCTS.IDENTITY, "identity");
+      assert.strictEqual(PRODUCTS.INVESTMENTS, "investments");
+      assert.strictEqual(PRODUCTS.LIABILITIES, "liabilities");
+    });
+
+    test("should expose COUNTRY_CODES in plugin", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      const { COUNTRY_CODES } = fastify.xplaid.constants;
+      assert.strictEqual(COUNTRY_CODES.US, "US");
+      assert.strictEqual(COUNTRY_CODES.CA, "CA");
+      assert.strictEqual(COUNTRY_CODES.GB, "GB");
+    });
+  });
+
+  describe("Raw Client Access", () => {
+    test("should expose raw Plaid client", async () => {
+      await fastify.register(xPlaid, {
+        clientId: "test_client_id",
+        secret: "test_secret",
+        environment: "sandbox",
+      });
+      await fastify.ready();
+
+      assert.ok(fastify.xplaid.raw, "raw client should exist");
+      assert.ok(typeof fastify.xplaid.raw === "object", "raw client should be an object");
+    });
+  });
+});
+
+describe("Link Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have createToken method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.link.createToken === "function");
+  });
+
+  test("should have getToken method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.link.getToken === "function");
+  });
+
+  test("should have exchangePublicToken method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.link.exchangePublicToken === "function");
+  });
+});
+
+describe("Accounts Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.accounts.get === "function");
+  });
+
+  test("should have getBalance method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.accounts.getBalance === "function");
+  });
+});
+
+describe("Transactions Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have sync method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.transactions.sync === "function");
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.transactions.get === "function");
+  });
+
+  test("should have refresh method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.transactions.refresh === "function");
+  });
+});
+
+describe("Identity Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.identity.get === "function");
+  });
+});
+
+describe("Auth Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.auth.get === "function");
+  });
+});
+
+describe("Investments Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have getHoldings method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.investments.getHoldings === "function");
+  });
+
+  test("should have getTransactions method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.investments.getTransactions === "function");
+  });
+});
+
+describe("Liabilities Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.liabilities.get === "function");
+  });
+});
+
+describe("Items Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have get method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.items.get === "function");
+  });
+
+  test("should have remove method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.items.remove === "function");
+  });
+
+  test("should have getInstitution method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.items.getInstitution === "function");
+  });
+
+  test("should have searchInstitutions method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.items.searchInstitutions === "function");
+  });
+});
+
+describe("Webhooks Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  test("should have update method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.webhooks.update === "function");
+  });
+
+  test("should have getVerificationKey method", async () => {
+    await fastify.register(xPlaid, {
+      clientId: "test_client_id",
+      secret: "test_secret",
+      environment: "sandbox",
+    });
+    await fastify.ready();
+
+    assert.ok(typeof fastify.xplaid.webhooks.getVerificationKey === "function");
+  });
+});