xero-hero/dist/common/instance/__tests__/operations.test.js

Heroic utilities to simplify and enable your progress with the [xero-node](https://www.npmjs.com/package/xero-node) SDK.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// src/common/instance/__tests__/operations.test.ts
var import_xero_node = require("xero-node");

// src/common/instance/operations.ts
var import_deep_cuts = require("deep-cuts");
var deepClone = (instance) => {
  if (instance && (0, import_deep_cuts.isObject)(instance)) {
    const { constructor } = instance;
    const clone = new constructor();
    for (const key in instance) {
      clone[key] = deepClone(instance[key]);
    }
    return clone;
  }
  return instance;
};

// src/accounting/attachments/requests.ts
var import_tranquil_stream = require("tranquil-stream");

// src/accounting/contacts/links.ts
var import_qs = __toESM(require("qs"));

// src/accounting/invoices/lineItems.ts
var import_deep_cuts2 = require("deep-cuts");

// src/accounting/journals/links.ts
var import_qs2 = __toESM(require("qs"));

// src/projects/timeEntries.ts
var import_deep_cuts3 = require("deep-cuts");

// src/common/instance/__tests__/operations.test.ts
var generateLineItemsWithCodes = (itemCodes) => {
  return itemCodes.map((itemCode) => {
    const lineItem = new import_xero_node.LineItem();
    lineItem.itemCode = String(itemCode);
    return lineItem;
  });
};
describe("common/instance/operations", () => {
  describe("deepClone()", () => {
    it("should return undefined if passed undefined", () => {
      expect(deepClone()).toBe(void 0);
    });
    it("should return null if passed null", () => {
      expect(deepClone(null)).toBe(null);
    });
    it("should return a number of passed a number", () => {
      expect(deepClone(572)).toBe(572);
    });
    it("should return a string if passed a string", () => {
      expect(deepClone("Hello, my name is...")).toBe("Hello, my name is...");
    });
    it("should return a boolean if passed a boolean", () => {
      expect(deepClone(true)).toBe(true);
    });
    it("should return a deep clone of a  simple object", () => {
      const original = {
        a: 1,
        b: {
          c: 2,
          d: {
            e: 3
          }
        }
      };
      const clone = deepClone(original);
      expect(clone).toEqual(original);
      expect(clone).not.toBe(original);
      expect(clone.b).not.toBe(original.b);
      expect(clone.b.d).not.toBe(original.b.d);
    });
    it("should be able to clone a LineItem but not point to the original instance", () => {
      const lineItem = new import_xero_node.LineItem();
      lineItem.unitAmount = 42;
      lineItem.quantity = 56;
      const clone = deepClone(lineItem);
      expect(clone).not.toBe(lineItem);
      expect(clone).toEqual(lineItem);
      expect(clone instanceof import_xero_node.LineItem).toBe(true);
    });
    it("should play nice with sub references on a LineItem", () => {
      const lineItemItem = new import_xero_node.LineItemItem();
      lineItemItem.name = "Koolaid";
      const lineItem = new import_xero_node.LineItem();
      lineItem.unitAmount = 42;
      lineItem.quantity = 56;
      lineItem.item = lineItemItem;
      const clone = deepClone(lineItem);
      expect(clone.item).not.toBe(lineItem.item);
      expect(clone.item).toEqual(lineItem.item);
      expect(clone.item instanceof import_xero_node.LineItemItem).toBe(true);
    });
    it("should be able to clone an Invoice but not point to the original instance", () => {
      const invoice = new import_xero_node.Invoice();
      invoice.reference = "Recent Charges";
      const clone = deepClone(invoice);
      expect(clone).not.toBe(invoice);
      expect(clone).toEqual(invoice);
      expect(clone instanceof import_xero_node.Invoice).toBe(true);
    });
    it("should play nice with sub references on an Invoice", () => {
      const contact = new import_xero_node.Contact();
      contact.name = "Koolaid Man";
      const invoice = new import_xero_node.Invoice();
      invoice.reference = "Recent Charges";
      invoice.contact = contact;
      const clone = deepClone(invoice);
      expect(clone.contact).not.toBe(invoice.contact);
      expect(clone.contact).toEqual(invoice.contact);
      expect(clone.contact instanceof import_xero_node.Contact).toBe(true);
    });
    it("should play nice with sub reference collections on an invoice", () => {
      const lineItems = generateLineItemsWithCodes([1, 50, 5e3]);
      const invoice = new import_xero_node.Invoice();
      invoice.reference = "Recent Charges";
      invoice.lineItems = lineItems;
      const clone = deepClone(invoice);
      for (let index = 0; index < lineItems.length; index++) {
        expect(clone.lineItems[index]).not.toBe(invoice.lineItems[index]);
        expect(clone.lineItems[index]).toEqual(invoice.lineItems[index]);
        expect(clone.lineItems[index] instanceof import_xero_node.LineItem).toBe(true);
      }
    });
    it("should play nice with enums on an Invoice", () => {
      const invoice = new import_xero_node.Invoice();
      invoice.reference = "Recent Charges";
      invoice.lineAmountTypes = import_xero_node.LineAmountTypes.Inclusive;
      const clone = deepClone(invoice);
      expect(clone.lineAmountTypes).toBe(invoice.lineAmountTypes);
    });
    it("should play nice with sub, sub references on an invoice", () => {
      const lineItemItem = new import_xero_node.LineItemItem();
      lineItemItem.name = "Koolaid";
      const lineItems = generateLineItemsWithCodes([777]);
      lineItems[0].item = lineItemItem;
      const invoice = new import_xero_node.Invoice();
      invoice.reference = "Recent Charges";
      invoice.lineItems = lineItems;
      const clone = deepClone(invoice);
      for (let index = 0; index < lineItems.length; index++) {
        expect(clone.lineItems[index].item).not.toBe(
          invoice.lineItems[index].item
        );
        expect(clone.lineItems[index].item).toEqual(
          invoice.lineItems[index].item
        );
        expect(clone.lineItems[index].item instanceof import_xero_node.LineItemItem).toBe(true);
      }
    });
  });
});
//# sourceMappingURL=operations.test.js.map