@yoryoboy/bi-mcp 1.10.0 → 1.13.0

package/dist/tests/vtex/vtex-write-simple-tools.test.js

@@ -0,0 +1,647 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { activateSkuHandler } from "../../src/tools/vtex/activate-sku.js";
+import { deactivateSkuHandler } from "../../src/tools/vtex/deactivate-sku.js";
+import { toggleUnlimitedQuantityHandler } from "../../src/tools/vtex/toggle-unlimited-quantity.js";
+import { updateInventoryHandler } from "../../src/tools/vtex/update-inventory.js";
+import { updateLeadTimeHandler } from "../../src/tools/vtex/update-lead-time.js";
+import { deleteSkuPriceHandler } from "../../src/tools/vtex/delete-sku-price.js";
+import { updateSkuPriceHandler } from "../../src/tools/vtex/update-sku-price.js";
+import {
+  updateSkuBasicFields
+} from "../../src/services/vtex/vtex-catalog-write.js";
+import {
+  getInventoryByWarehouse,
+  updateInventoryLeadTime,
+  updateInventoryQuantity
+} from "../../src/services/vtex/vtex-logistics.js";
+import { getSkuPrice } from "../../src/services/vtex/vtex-pricing.js";
+import {
+  deleteSkuPrice,
+  updateSkuPrice
+} from "../../src/services/vtex/vtex-pricing-write.js";
+import {
+  buildWriteSuccessResponse,
+  handleVtexWriteError,
+  requireExplicitConfirmation,
+  resolveVtexWriteProfile
+} from "../../src/tools/vtex/write-helpers.js";
+vi.mock("../../src/tools/vtex/write-helpers.js", () => ({
+  vtexProfileIdSchemaField: z.string().optional(),
+  confirmationSchemaField: z.boolean().optional(),
+  confirmationNoteSchemaField: z.string().optional(),
+  resolveVtexWriteProfile: vi.fn(),
+  buildWriteSuccessResponse: vi.fn((params) => ({
+    kind: "success",
+    params
+  })),
+  requireExplicitConfirmation: vi.fn(),
+  handleVtexWriteError: vi.fn((err, fallback) => ({
+    kind: "error",
+    fallback,
+    err
+  }))
+}));
+vi.mock("../../src/services/vtex/vtex-catalog-write.js", () => ({
+  updateSkuBasicFields: vi.fn()
+}));
+vi.mock("../../src/services/vtex/vtex-logistics.js", () => ({
+  getInventoryByWarehouse: vi.fn(),
+  updateInventoryQuantity: vi.fn(),
+  updateInventoryLeadTime: vi.fn()
+}));
+vi.mock("../../src/services/vtex/vtex-pricing.js", () => ({
+  getSkuPrice: vi.fn()
+}));
+vi.mock("../../src/services/vtex/vtex-pricing-write.js", () => ({
+  updateSkuPrice: vi.fn(),
+  deleteSkuPrice: vi.fn()
+}));
+describe("VTEX write simple tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(requireExplicitConfirmation).mockReturnValue(null);
+    vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+      ok: true,
+      value: { profileId: "profile-1" }
+    });
+  });
+  describe("activateSkuHandler", () => {
+    it("activates a sku using the fetched sku snapshot", async () => {
+      const beforeSku = { Id: "sku-1", IsActive: false, Name: "Before" };
+      const afterSku = { Id: "sku-1", IsActive: true, Name: "Before" };
+      vi.mocked(updateSkuBasicFields).mockResolvedValue({
+        before: beforeSku,
+        payload: { IsActive: true, Name: "Before" },
+        after: afterSku
+      });
+      const result = await activateSkuHandler({
+        profileId: "custom",
+        skuId: "sku-1"
+      });
+      expect(resolveVtexWriteProfile).toHaveBeenCalledWith("custom");
+      expect(updateSkuBasicFields).toHaveBeenCalledWith("profile-1", "sku-1", {
+        isActive: true
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "activate_sku",
+        resourceId: "sku-1",
+        riskLevel: "medium",
+        message: "SKU activated successfully.",
+        before: beforeSku,
+        after: afterSku,
+        details: { sku_id: "sku-1" }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "activate_sku" })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await activateSkuHandler({ skuId: "sku-1" });
+      expect(result).toEqual({ selection: true });
+      expect(updateSkuBasicFields).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(updateSkuBasicFields).mockRejectedValue(new Error("boom"));
+      const result = await activateSkuHandler({
+        profileId: "custom",
+        skuId: "sku-1"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to activate SKU sku-1"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to activate SKU sku-1",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("deactivateSkuHandler", () => {
+    it("deactivates a sku using the fetched sku snapshot", async () => {
+      const beforeSku = { Id: "sku-2", IsActive: true, Name: "Before" };
+      const afterSku = { Id: "sku-2", IsActive: false, Name: "Before" };
+      vi.mocked(updateSkuBasicFields).mockResolvedValue({
+        before: beforeSku,
+        payload: { IsActive: false, Name: "Before" },
+        after: afterSku
+      });
+      const result = await deactivateSkuHandler({
+        profileId: "custom",
+        skuId: "sku-2"
+      });
+      expect(updateSkuBasicFields).toHaveBeenCalledWith("profile-1", "sku-2", {
+        isActive: false
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "deactivate_sku",
+        resourceId: "sku-2",
+        riskLevel: "medium",
+        message: "SKU deactivated successfully.",
+        before: beforeSku,
+        after: afterSku,
+        details: { sku_id: "sku-2" }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "deactivate_sku" })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await deactivateSkuHandler({ skuId: "sku-2" });
+      expect(result).toEqual({ selection: true });
+      expect(updateSkuBasicFields).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(updateSkuBasicFields).mockRejectedValue(new Error("boom"));
+      const result = await deactivateSkuHandler({
+        profileId: "custom",
+        skuId: "sku-2"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to deactivate SKU sku-2"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to deactivate SKU sku-2",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("toggleUnlimitedQuantityHandler", () => {
+    it("reuses the current total quantity when toggling unlimited mode", async () => {
+      const beforeInventory = [
+        {
+          skuId: "sku-3",
+          warehouseId: "wh-1",
+          totalQuantity: 9,
+          isUnlimited: false
+        }
+      ];
+      const afterInventory = [
+        {
+          skuId: "sku-3",
+          warehouseId: "wh-1",
+          totalQuantity: 9,
+          isUnlimited: true
+        }
+      ];
+      vi.mocked(getInventoryByWarehouse).mockResolvedValueOnce(beforeInventory).mockResolvedValueOnce(afterInventory);
+      const result = await toggleUnlimitedQuantityHandler({
+        profileId: "custom",
+        skuId: "sku-3",
+        warehouseId: "wh-1",
+        unlimitedQuantity: true
+      });
+      expect(updateInventoryQuantity).toHaveBeenCalledWith(
+        "profile-1",
+        "sku-3",
+        "wh-1",
+        { quantity: 9, unlimitedQuantity: true }
+      );
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "toggle_unlimited_quantity",
+        resourceId: "sku-3",
+        riskLevel: "low",
+        message: "Unlimited quantity mode updated successfully.",
+        before: beforeInventory[0],
+        after: afterInventory[0],
+        details: {
+          sku_id: "sku-3",
+          warehouse_id: "wh-1",
+          unlimited_quantity: true
+        }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({
+          operation: "toggle_unlimited_quantity"
+        })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await toggleUnlimitedQuantityHandler({
+        skuId: "sku-3",
+        warehouseId: "wh-1",
+        unlimitedQuantity: true
+      });
+      expect(result).toEqual({ selection: true });
+      expect(getInventoryByWarehouse).not.toHaveBeenCalled();
+      expect(updateInventoryQuantity).not.toHaveBeenCalled();
+    });
+    it("maps missing inventory snapshots through handleVtexWriteError", async () => {
+      vi.mocked(getInventoryByWarehouse).mockResolvedValueOnce([]);
+      const result = await toggleUnlimitedQuantityHandler({
+        profileId: "custom",
+        skuId: "sku-3",
+        warehouseId: "wh-1",
+        unlimitedQuantity: true
+      });
+      expect(updateInventoryQuantity).not.toHaveBeenCalled();
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to update unlimited quantity mode for SKU sku-3 in wh-1"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update unlimited quantity mode for SKU sku-3 in wh-1",
+        err: expect.any(Error)
+      });
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(getInventoryByWarehouse).mockRejectedValue(new Error("boom"));
+      const result = await toggleUnlimitedQuantityHandler({
+        profileId: "custom",
+        skuId: "sku-3",
+        warehouseId: "wh-1",
+        unlimitedQuantity: true
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to update unlimited quantity mode for SKU sku-3 in wh-1"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update unlimited quantity mode for SKU sku-3 in wh-1",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("updateLeadTimeHandler", () => {
+    it("updates lead time and returns before/after snapshots", async () => {
+      const beforeInventory = [
+        { skuId: "sku-4", warehouseId: "wh-2", leadTime: "1.00:00:00" }
+      ];
+      const afterInventory = [
+        { skuId: "sku-4", warehouseId: "wh-2", leadTime: "2.00:00:00" }
+      ];
+      vi.mocked(getInventoryByWarehouse).mockResolvedValueOnce(beforeInventory).mockResolvedValueOnce(afterInventory);
+      const result = await updateLeadTimeHandler({
+        profileId: "custom",
+        skuId: "sku-4",
+        warehouseId: "wh-2",
+        leadTime: "2.00:00:00"
+      });
+      expect(updateInventoryLeadTime).toHaveBeenCalledWith(
+        "profile-1",
+        "sku-4",
+        "wh-2",
+        { leadTime: "2.00:00:00" }
+      );
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "update_lead_time",
+        resourceId: "sku-4",
+        riskLevel: "low",
+        message: "Lead time updated successfully.",
+        before: beforeInventory[0],
+        after: afterInventory[0],
+        details: {
+          sku_id: "sku-4",
+          warehouse_id: "wh-2",
+          lead_time: "2.00:00:00"
+        }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "update_lead_time" })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await updateLeadTimeHandler({
+        skuId: "sku-4",
+        warehouseId: "wh-2",
+        leadTime: "2.00:00:00"
+      });
+      expect(result).toEqual({ selection: true });
+      expect(getInventoryByWarehouse).not.toHaveBeenCalled();
+      expect(updateInventoryLeadTime).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(getInventoryByWarehouse).mockRejectedValue(new Error("boom"));
+      const result = await updateLeadTimeHandler({
+        profileId: "custom",
+        skuId: "sku-4",
+        warehouseId: "wh-2",
+        leadTime: "2.00:00:00"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to update lead time for SKU sku-4 in wh-2"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update lead time for SKU sku-4 in wh-2",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("updateInventoryHandler", () => {
+    it("updates inventory with forwarded quantity and sync timestamp", async () => {
+      const beforeInventory = [
+        { skuId: "sku-5", warehouseId: "wh-3", totalQuantity: 4 }
+      ];
+      const afterInventory = [
+        { skuId: "sku-5", warehouseId: "wh-3", totalQuantity: 12 }
+      ];
+      vi.mocked(getInventoryByWarehouse).mockResolvedValueOnce(beforeInventory).mockResolvedValueOnce(afterInventory);
+      const result = await updateInventoryHandler({
+        profileId: "custom",
+        skuId: "sku-5",
+        warehouseId: "wh-3",
+        quantity: 12,
+        unlimitedQuantity: false,
+        dateUtcOnBalanceSystem: "2026-06-01T10:00:00Z"
+      });
+      expect(updateInventoryQuantity).toHaveBeenCalledWith(
+        "profile-1",
+        "sku-5",
+        "wh-3",
+        {
+          quantity: 12,
+          unlimitedQuantity: false,
+          dateUtcOnBalanceSystem: "2026-06-01T10:00:00Z"
+        }
+      );
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "update_inventory",
+        resourceId: "sku-5",
+        riskLevel: "low",
+        message: "Inventory quantity updated successfully.",
+        before: beforeInventory[0],
+        after: afterInventory[0],
+        details: {
+          sku_id: "sku-5",
+          warehouse_id: "wh-3",
+          quantity: 12,
+          unlimited_quantity: false
+        }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "update_inventory" })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await updateInventoryHandler({
+        skuId: "sku-5",
+        warehouseId: "wh-3",
+        quantity: 12,
+        unlimitedQuantity: false
+      });
+      expect(result).toEqual({ selection: true });
+      expect(getInventoryByWarehouse).not.toHaveBeenCalled();
+      expect(updateInventoryQuantity).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(getInventoryByWarehouse).mockRejectedValue(new Error("boom"));
+      const result = await updateInventoryHandler({
+        profileId: "custom",
+        skuId: "sku-5",
+        warehouseId: "wh-3",
+        quantity: 12,
+        unlimitedQuantity: false
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to update inventory quantity for SKU sku-5 in wh-3"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update inventory quantity for SKU sku-5 in wh-3",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("deleteSkuPriceHandler", () => {
+    it("requires explicit confirmation before deleting pricing", async () => {
+      vi.mocked(requireExplicitConfirmation).mockReturnValue({ confirmation_required: true });
+      const result = await deleteSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-7"
+      });
+      expect(requireExplicitConfirmation).toHaveBeenCalledWith(void 0, "delete_sku_price", {
+        sku_id: "sku-7"
+      });
+      expect(result).toEqual({ confirmation_required: true });
+      expect(resolveVtexWriteProfile).not.toHaveBeenCalled();
+      expect(deleteSkuPrice).not.toHaveBeenCalled();
+    });
+    it("deletes pricing and returns the minimal success contract", async () => {
+      const result = await deleteSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-7",
+        confirmed: true,
+        confirmationNote: "User confirmed deleting the SKU price record."
+      });
+      expect(resolveVtexWriteProfile).toHaveBeenCalledWith("custom");
+      expect(deleteSkuPrice).toHaveBeenCalledWith("profile-1", "sku-7");
+      expect(result).toEqual({
+        content: [
+          {
+            text: expect.stringContaining('"operation": "delete_sku_price"'),
+            type: "text"
+          }
+        ],
+        structuredContent: {
+          success: true,
+          profile_id: "profile-1",
+          operation: "delete_sku_price",
+          resource_id: "sku-7",
+          risk_level: "high",
+          confirmed: true,
+          message: "SKU price delete request accepted by VTEX.",
+          warnings: [
+            "Price reads may remain stale for several minutes after a successful delete while VTEX propagates the change."
+          ]
+        },
+        _meta: {
+          mimeType: "application/json"
+        }
+      });
+      expect(buildWriteSuccessResponse).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(deleteSkuPrice).mockRejectedValue(new Error("boom"));
+      const result = await deleteSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-7",
+        confirmed: true
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to delete price for SKU sku-7"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to delete price for SKU sku-7",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("updateSkuPriceHandler", () => {
+    it("updates sku pricing and re-fetches before/after price snapshots", async () => {
+      const beforePrice = { itemId: "sku-6", basePrice: 100, costPrice: 80 };
+      const afterPrice = { itemId: "sku-6", basePrice: 120, costPrice: 80 };
+      vi.mocked(getSkuPrice).mockResolvedValueOnce(beforePrice).mockResolvedValueOnce(afterPrice);
+      const fixedPrices = [
+        {
+          tradePolicyId: "1",
+          value: 110,
+          listPrice: 130,
+          minQuantity: 2,
+          dateRange: {
+            from: "2026-06-01T00:00:00Z",
+            to: "2026-06-30T00:00:00Z"
+          }
+        }
+      ];
+      const result = await updateSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-6",
+        basePrice: 120,
+        costPrice: 80,
+        listPrice: 140,
+        fixedPrices
+      });
+      expect(updateSkuPrice).toHaveBeenCalledWith("profile-1", "sku-6", {
+        basePrice: 120,
+        costPrice: 80,
+        markup: void 0,
+        listPrice: 140,
+        fixedPrices
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "update_sku_price",
+        resourceId: "sku-6",
+        riskLevel: "low",
+        message: "SKU price updated successfully.",
+        before: beforePrice,
+        after: afterPrice,
+        details: { sku_id: "sku-6" }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "update_sku_price" })
+      });
+    });
+    it("does not swallow unrelated 404 price lookup failures", async () => {
+      const generic404Error = {
+        isAxiosError: true,
+        response: { status: 404, data: { message: "SKU pricing endpoint unavailable" } },
+        message: "Request failed with status code 404"
+      };
+      vi.mocked(getSkuPrice).mockRejectedValue(generic404Error);
+      const result = await updateSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-6",
+        basePrice: 120
+      });
+      expect(updateSkuPrice).not.toHaveBeenCalled();
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        generic404Error,
+        "Failed to update price for SKU sku-6"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update price for SKU sku-6",
+        err: generic404Error
+      });
+    });
+    it("creates missing pricing when the seed SKU has no price snapshot yet", async () => {
+      const missingPriceError = {
+        isAxiosError: true,
+        response: { status: 404, data: { message: "Price not found" } },
+        message: "Request failed with status code 404"
+      };
+      const afterPrice = { itemId: "sku-6", basePrice: 1e4, listPrice: 1e4 };
+      vi.mocked(getSkuPrice).mockRejectedValueOnce(missingPriceError).mockResolvedValueOnce(afterPrice);
+      const result = await updateSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-6",
+        basePrice: 100,
+        listPrice: 100
+      });
+      expect(updateSkuPrice).toHaveBeenCalledWith("profile-1", "sku-6", {
+        basePrice: 100,
+        costPrice: void 0,
+        markup: void 0,
+        listPrice: 100,
+        fixedPrices: void 0
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "update_sku_price",
+        resourceId: "sku-6",
+        riskLevel: "low",
+        message: "SKU price updated successfully.",
+        before: null,
+        after: afterPrice,
+        details: { sku_id: "sku-6" }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "update_sku_price" })
+      });
+    });
+    it("returns profile selection payload without mutating anything", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await updateSkuPriceHandler({
+        skuId: "sku-6",
+        basePrice: 120
+      });
+      expect(result).toEqual({ selection: true });
+      expect(getSkuPrice).not.toHaveBeenCalled();
+      expect(updateSkuPrice).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(getSkuPrice).mockRejectedValue(new Error("boom"));
+      const result = await updateSkuPriceHandler({
+        profileId: "custom",
+        skuId: "sku-6",
+        basePrice: 120
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to update price for SKU sku-6"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to update price for SKU sku-6",
+        err: expect.any(Error)
+      });
+    });
+  });
+});
+//# sourceMappingURL=vtex-write-simple-tools.test.js.map