pleno-vue/tests/unit/red-car-detector.spec.js

import { describe, expect, it } from "vitest";

import {
  DEFAULT_RED_CAR_ATTRIBUTE_KEYS,
  extractAttributeKey,
  extractAttributeKeys,
  getRedCarAttributeKeys,
  isRedCarCustomer,
} from "@/composables/redCarDetector.js";

describe("redCarDetector.extractAttributeKey", () => {
  it("returns trimmed string for plain string entries", () => {
    expect(extractAttributeKey("isRedCar")).toBe("isRedCar");
    expect(extractAttributeKey("  invoiceAllOrdersIndividually  ")).toBe("invoiceAllOrdersIndividually");
  });

  it("extracts the attribute field from object rows", () => {
    expect(extractAttributeKey({ attribute: "isRedCar" })).toBe("isRedCar");
    expect(extractAttributeKey({ attribute: "isRedCar", customer_number: 42 })).toBe("isRedCar");
  });

  it("falls back to key/name aliases when attribute is missing", () => {
    expect(extractAttributeKey({ key: "redCar" })).toBe("redCar");
    expect(extractAttributeKey({ name: "red_car" })).toBe("red_car");
  });

  it("returns empty string for invalid input", () => {
    expect(extractAttributeKey(null)).toBe("");
    expect(extractAttributeKey(undefined)).toBe("");
    expect(extractAttributeKey(123)).toBe("");
    expect(extractAttributeKey({})).toBe("");
    expect(extractAttributeKey({ attribute: "" })).toBe("");
  });
});

describe("redCarDetector.extractAttributeKeys", () => {
  it("returns the attribute key for each row", () => {
    expect(extractAttributeKeys(["isRedCar", { attribute: "redCar" }, { key: "is_red_car" }])).toEqual([
      "isRedCar",
      "redCar",
      "is_red_car",
    ]);
  });

  it("filters out invalid rows and empty keys", () => {
    expect(
      extractAttributeKeys([null, undefined, "isRedCar", "", { attribute: "" }, { attribute: "  redCar  " }])
    ).toEqual(["isRedCar", "redCar"]);
  });

  it("returns an empty array for non-array input", () => {
    expect(extractAttributeKeys(null)).toEqual([]);
    expect(extractAttributeKeys(undefined)).toEqual([]);
    expect(extractAttributeKeys("isRedCar")).toEqual([]);
  });
});

describe("redCarDetector.isRedCarCustomer (positive cases)", () => {
  it("flags a customer with the default isRedCar attribute", () => {
    expect(isRedCarCustomer([{ attribute: "isRedCar" }])).toBe(true);
  });

  it("flags any of the default attribute keys", () => {
    for (const key of DEFAULT_RED_CAR_ATTRIBUTE_KEYS) {
      expect(isRedCarCustomer([{ attribute: key }])).toBe(true);
    }
  });

  it("flags when the attribute is a plain string", () => {
    expect(isRedCarCustomer(["isRedCar"])).toBe(true);
    expect(isRedCarCustomer(["red_car"])).toBe(true);
  });

  it("matches case-insensitively", () => {
    expect(isRedCarCustomer([{ attribute: "ISREDCAR" }])).toBe(true);
    expect(isRedCarCustomer([{ attribute: "isredcar" }])).toBe(true);
  });

  it("flags a customer with a custom configured key", () => {
    expect(
      isRedCarCustomer([{ attribute: "needsGentleWash" }], {
        attributeKeys: ["needsGentleWash"],
      })
    ).toBe(true);
  });

  it("flags when at least one matching attribute is present among others", () => {
    expect(
      isRedCarCustomer([
        { attribute: "invoiceAllOrdersIndividually" },
        { attribute: "isRedCar" },
        { attribute: "onlyTankCleaning" },
      ])
    ).toBe(true);
  });
});

describe("redCarDetector.isRedCarCustomer (negative cases)", () => {
  it("returns false for an empty attribute list", () => {
    expect(isRedCarCustomer([])).toBe(false);
  });

  it("returns false when no attribute matches the default keys", () => {
    expect(isRedCarCustomer([{ attribute: "onlyTankCleaning" }, { attribute: "invoiceAllOrdersIndividually" }])).toBe(
      false
    );
  });

  it("returns false for null/undefined input", () => {
    expect(isRedCarCustomer(null)).toBe(false);
    expect(isRedCarCustomer(undefined)).toBe(false);
  });

  it("returns false when configured keys are all empty strings", () => {
    expect(isRedCarCustomer([{ attribute: "isRedCar" }], { attributeKeys: ["", "  "] })).toBe(false);
  });

  it("returns false for an unrelated custom key when defaults are used", () => {
    expect(isRedCarCustomer([{ attribute: "needsGentleWash" }])).toBe(false);
  });

  it("returns false for a custom key when a different custom key is configured", () => {
    expect(
      isRedCarCustomer([{ attribute: "needsGentleWash" }], {
        attributeKeys: ["isRedCar"],
      })
    ).toBe(false);
  });
});

describe("redCarDetector.getRedCarAttributeKeys", () => {
  it("returns the default keys when no override is given", () => {
    const keys = getRedCarAttributeKeys();
    expect(keys).toContain("isredcar");
    expect(keys).toContain("is_red_car");
    expect(keys).toContain("redcar");
    expect(keys).toContain("red_car");
  });

  it("normalizes and deduplicates custom keys", () => {
    const keys = getRedCarAttributeKeys({
      attributeKeys: ["  isRedCar  ", "ISREDCAR", "", "redCar"],
    });
    expect(keys).toEqual(["isredcar", "redcar"]);
  });

  it("returns an empty array when no valid keys are configured", () => {
    expect(getRedCarAttributeKeys({ attributeKeys: ["", "  "] })).toEqual([]);
  });
});