@xenterprises/fastify-xsignwell 1.0.0

package/test/xSignwell.test.js

@@ -0,0 +1,539 @@
+/**
+ * xSignwell Tests
+ *
+ * Test suite for the xSignwell plugin.
+ */
+
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import Fastify from "fastify";
+import xSignwell from "../src/xSignwell.js";
+
+// Mock fetch globally
+const originalFetch = global.fetch;
+
+function mockFetch(responses = {}) {
+  global.fetch = mock.fn(async (url, options) => {
+    const path = new URL(url).pathname;
+
+    // Find matching response
+    for (const [pattern, response] of Object.entries(responses)) {
+      if (path.includes(pattern)) {
+        return {
+          ok: response.ok !== false,
+          status: response.status || 200,
+          text: async () => JSON.stringify(response.data || {}),
+          json: async () => response.data || {},
+        };
+      }
+    }
+
+    // Default success response
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ success: true }),
+      json: async () => ({ success: true }),
+    };
+  });
+}
+
+function restoreFetch() {
+  global.fetch = originalFetch;
+}
+
+describe("xSignwell Plugin", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify({ logger: false });
+    mockFetch({
+      "/me": { data: { email: "test@example.com", name: "Test User" } },
+    });
+  });
+
+  afterEach(async () => {
+    restoreFetch();
+    await fastify.close();
+  });
+
+  describe("Plugin Registration", () => {
+    test("should register successfully with valid API key", async () => {
+      await fastify.register(xSignwell, {
+        apiKey: "test_api_key",
+      });
+      await fastify.ready();
+
+      assert.ok(fastify.xsignwell, "xsignwell should exist");
+      assert.ok(fastify.xsignwell.documents, "xsignwell.documents should exist");
+      assert.ok(fastify.xsignwell.templates, "xsignwell.templates should exist");
+      assert.ok(fastify.xsignwell.webhooks, "xsignwell.webhooks should exist");
+      assert.ok(fastify.xsignwell.bulkSend, "xsignwell.bulkSend should exist");
+      assert.ok(fastify.xsignwell.me, "xsignwell.me should exist");
+      assert.ok(fastify.xsignwell.config, "xsignwell.config should exist");
+    });
+
+    test("should throw error without API key", async () => {
+      await assert.rejects(
+        async () => {
+          await fastify.register(xSignwell, {});
+          await fastify.ready();
+        },
+        /apiKey is required/
+      );
+    });
+
+    test("should skip registration when active is false", async () => {
+      await fastify.register(xSignwell, {
+        apiKey: "test_api_key",
+        active: false,
+      });
+      await fastify.ready();
+
+      assert.ok(!fastify.xsignwell, "xsignwell should not exist");
+    });
+
+    test("should store test mode configuration", async () => {
+      await fastify.register(xSignwell, {
+        apiKey: "test_api_key",
+        testMode: true,
+      });
+      await fastify.ready();
+
+      assert.strictEqual(fastify.xsignwell.config.testMode, true);
+    });
+  });
+
+  describe("Account Info", () => {
+    test("should get account info", async () => {
+      await fastify.register(xSignwell, {
+        apiKey: "test_api_key",
+      });
+      await fastify.ready();
+
+      const account = await fastify.xsignwell.me();
+      assert.strictEqual(account.email, "test@example.com");
+    });
+  });
+});
+
+describe("Documents Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify({ logger: false });
+  });
+
+  afterEach(async () => {
+    restoreFetch();
+    await fastify.close();
+  });
+
+  test("should create a document", async () => {
+    mockFetch({
+      "/documents": {
+        data: {
+          id: "doc_123",
+          name: "Test Document",
+          status: "draft",
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const doc = await fastify.xsignwell.documents.create({
+      name: "Test Document",
+      recipients: [
+        { email: "john@example.com", name: "John Doe" },
+      ],
+      files: [
+        { name: "test.pdf", url: "https://example.com/test.pdf" },
+      ],
+    });
+
+    assert.strictEqual(doc.id, "doc_123");
+    assert.strictEqual(doc.name, "Test Document");
+  });
+
+  test("should create document from template", async () => {
+    mockFetch({
+      "/document_templates/tpl_123/documents": {
+        data: {
+          id: "doc_456",
+          template_id: "tpl_123",
+          status: "pending",
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const doc = await fastify.xsignwell.documents.createFromTemplate("tpl_123", {
+      recipients: [
+        { id: "signer_1", email: "john@example.com", name: "John Doe" },
+      ],
+      fields: {
+        name: "John Doe",
+        date: "2025-01-01",
+      },
+    });
+
+    assert.strictEqual(doc.id, "doc_456");
+    assert.strictEqual(doc.template_id, "tpl_123");
+  });
+
+  test("should get a document", async () => {
+    mockFetch({
+      "/documents/doc_123": {
+        data: {
+          id: "doc_123",
+          name: "Test Document",
+          status: "completed",
+          recipients: [
+            { id: "r_1", email: "john@example.com", status: "signed" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const doc = await fastify.xsignwell.documents.get("doc_123");
+
+    assert.strictEqual(doc.id, "doc_123");
+    assert.strictEqual(doc.status, "completed");
+  });
+
+  test("should send a document", async () => {
+    mockFetch({
+      "/documents/doc_123/send": {
+        data: { id: "doc_123", status: "pending" },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.documents.send("doc_123");
+
+    assert.strictEqual(result.status, "pending");
+  });
+
+  test("should send reminder", async () => {
+    mockFetch({
+      "/documents/doc_123/remind": {
+        data: { success: true },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.documents.remind("doc_123");
+
+    assert.ok(result.success);
+  });
+
+  test("should delete a document", async () => {
+    mockFetch({
+      "/documents/doc_123": {
+        data: { success: true },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.documents.remove("doc_123");
+
+    assert.ok(result.success);
+  });
+
+  test("should get completed PDF", async () => {
+    mockFetch({
+      "/documents/doc_123/completed_pdf": {
+        data: {
+          file_url: "https://signwell.com/documents/doc_123.pdf",
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.documents.getCompletedPdf("doc_123");
+
+    assert.ok(result.file_url);
+  });
+});
+
+describe("Templates Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify({ logger: false });
+  });
+
+  afterEach(async () => {
+    restoreFetch();
+    await fastify.close();
+  });
+
+  test("should get a template", async () => {
+    mockFetch({
+      "/document_templates/tpl_123": {
+        data: {
+          id: "tpl_123",
+          name: "NDA Template",
+          fields: [
+            { name: "company_name", type: "text" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const template = await fastify.xsignwell.templates.get("tpl_123");
+
+    assert.strictEqual(template.id, "tpl_123");
+    assert.strictEqual(template.name, "NDA Template");
+  });
+
+  test("should list templates", async () => {
+    mockFetch({
+      "/document_templates": {
+        data: {
+          templates: [
+            { id: "tpl_1", name: "Template 1" },
+            { id: "tpl_2", name: "Template 2" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.templates.list();
+
+    assert.strictEqual(result.templates.length, 2);
+  });
+
+  test("should create a template", async () => {
+    mockFetch({
+      "/document_templates": {
+        data: {
+          id: "tpl_new",
+          name: "New Template",
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const template = await fastify.xsignwell.templates.create({
+      name: "New Template",
+      files: [{ name: "doc.pdf", url: "https://example.com/doc.pdf" }],
+    });
+
+    assert.strictEqual(template.id, "tpl_new");
+  });
+
+  test("should delete a template", async () => {
+    mockFetch({
+      "/document_templates/tpl_123": {
+        data: { success: true },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.templates.remove("tpl_123");
+
+    assert.ok(result.success);
+  });
+});
+
+describe("Webhooks Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify({ logger: false });
+  });
+
+  afterEach(async () => {
+    restoreFetch();
+    await fastify.close();
+  });
+
+  test("should list webhooks", async () => {
+    mockFetch({
+      "/hooks": {
+        data: {
+          hooks: [
+            { id: "hook_1", callback_url: "https://example.com/webhook" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.webhooks.list();
+
+    assert.ok(result.hooks);
+  });
+
+  test("should create a webhook", async () => {
+    mockFetch({
+      "/hooks": {
+        data: {
+          id: "hook_new",
+          callback_url: "https://example.com/webhook",
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const webhook = await fastify.xsignwell.webhooks.create({
+      callbackUrl: "https://example.com/webhook",
+    });
+
+    assert.strictEqual(webhook.id, "hook_new");
+  });
+
+  test("should delete a webhook", async () => {
+    mockFetch({
+      "/hooks/hook_123": {
+        data: { success: true },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.webhooks.remove("hook_123");
+
+    assert.ok(result.success);
+  });
+
+  test("should parse webhook event", async () => {
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const payload = {
+      event: "document.completed",
+      document: {
+        id: "doc_123",
+        name: "Test Document",
+      },
+      timestamp: "2025-01-01T00:00:00Z",
+    };
+
+    const event = fastify.xsignwell.webhooks.parseEvent(payload);
+
+    assert.strictEqual(event.event, "document.completed");
+    assert.strictEqual(event.documentId, "doc_123");
+    assert.ok(event.document);
+  });
+
+  test("should have event type constants", async () => {
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const events = fastify.xsignwell.webhooks.events;
+
+    assert.strictEqual(events.DOCUMENT_COMPLETED, "document.completed");
+    assert.strictEqual(events.DOCUMENT_SIGNED, "document.signed");
+    assert.strictEqual(events.DOCUMENT_DECLINED, "document.declined");
+  });
+});
+
+describe("Bulk Send Service", () => {
+  let fastify;
+
+  beforeEach(async () => {
+    fastify = Fastify({ logger: false });
+  });
+
+  afterEach(async () => {
+    restoreFetch();
+    await fastify.close();
+  });
+
+  test("should create a bulk send", async () => {
+    mockFetch({
+      "/bulk_sends": {
+        data: {
+          id: "bulk_123",
+          status: "processing",
+          document_count: 2,
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const bulkSend = await fastify.xsignwell.bulkSend.create({
+      templateId: "tpl_123",
+      recipients: [
+        { email: "john@example.com", name: "John" },
+        { email: "jane@example.com", name: "Jane" },
+      ],
+    });
+
+    assert.strictEqual(bulkSend.id, "bulk_123");
+    assert.strictEqual(bulkSend.document_count, 2);
+  });
+
+  test("should list bulk sends", async () => {
+    mockFetch({
+      "/bulk_sends": {
+        data: {
+          bulk_sends: [
+            { id: "bulk_1", status: "completed" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.bulkSend.list();
+
+    assert.ok(result.bulk_sends);
+  });
+
+  test("should get bulk send documents", async () => {
+    mockFetch({
+      "/bulk_sends/bulk_123/documents": {
+        data: {
+          documents: [
+            { id: "doc_1", status: "pending" },
+            { id: "doc_2", status: "completed" },
+          ],
+        },
+      },
+    });
+
+    await fastify.register(xSignwell, { apiKey: "test_key" });
+    await fastify.ready();
+
+    const result = await fastify.xsignwell.bulkSend.getDocuments("bulk_123");
+
+    assert.strictEqual(result.documents.length, 2);
+  });
+});