@hyperfixi/testing-framework 2.0.0

package/dist/assertions.mjs

@@ -0,0 +1,621 @@
+import { diffLines } from 'diff';
+
+/* Testing Framework for HyperFixi Applications */
+
+var AssertionError = class extends Error {
+  constructor(message, expected, actual, operator) {
+    super(message);
+    this.expected = expected;
+    this.actual = actual;
+    this.operator = operator;
+    this.name = "AssertionError";
+  }
+};
+function deepEqual(actual, expected) {
+  if (actual === expected) return true;
+  if (actual == null || expected == null) return actual === expected;
+  if (typeof actual !== typeof expected) return false;
+  if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+  }
+  if (actual instanceof RegExp && expected instanceof RegExp) {
+    return actual.toString() === expected.toString();
+  }
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    if (actual.length !== expected.length) return false;
+    for (let i = 0; i < actual.length; i++) {
+      if (!deepEqual(actual[i], expected[i])) return false;
+    }
+    return true;
+  }
+  if (typeof actual === "object" && typeof expected === "object") {
+    const actualKeys = Object.keys(actual);
+    const expectedKeys = Object.keys(expected);
+    if (actualKeys.length !== expectedKeys.length) return false;
+    for (const key of actualKeys) {
+      if (!expectedKeys.includes(key)) return false;
+      if (!deepEqual(actual[key], expected[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function generateDiff(actual, expected) {
+  const actualStr = typeof actual === "string" ? actual : JSON.stringify(actual, null, 2);
+  const expectedStr = typeof expected === "string" ? expected : JSON.stringify(expected, null, 2);
+  const diff = diffLines(expectedStr, actualStr);
+  return diff.map((part) => {
+    const prefix = part.added ? "+" : part.removed ? "-" : " ";
+    return part.value.split("\n").map((line) => `${prefix} ${line}`).join("\n");
+  }).join("\n");
+}
+function isInDocument(element) {
+  if (typeof document === "undefined") return false;
+  return document.contains(element);
+}
+function isVisible(element) {
+  if (!isInDocument(element)) return false;
+  const style = window.getComputedStyle(element);
+  return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+}
+var ExpectMatcherImpl = class _ExpectMatcherImpl {
+  constructor(actual, isNot = false) {
+    this.actual = actual;
+    this.isNot = isNot;
+  }
+  get not() {
+    return new _ExpectMatcherImpl(this.actual, !this.isNot);
+  }
+  get resolves() {
+    if (!this.isPromise(this.actual)) {
+      throw new AssertionError("Expected value to be a Promise");
+    }
+    return new _ExpectMatcherImpl(
+      this.actual.then((value) => value),
+      this.isNot
+    );
+  }
+  get rejects() {
+    if (!this.isPromise(this.actual)) {
+      throw new AssertionError("Expected value to be a Promise");
+    }
+    return new _ExpectMatcherImpl(
+      this.actual.then(
+        (value) => {
+          throw new Error("Promise did not reject");
+        },
+        (error) => error
+      ),
+      this.isNot
+    );
+  }
+  toBe(expected) {
+    const passed = this.actual === expected;
+    this.assert(
+      passed,
+      "toBe",
+      expected,
+      `Expected ${this.format(this.actual)} to be ${this.format(expected)}`
+    );
+  }
+  toEqual(expected) {
+    const passed = deepEqual(this.actual, expected);
+    this.assert(
+      passed,
+      "toEqual",
+      expected,
+      `Expected ${this.format(this.actual)} to equal ${this.format(expected)}`
+    );
+  }
+  toStrictEqual(expected) {
+    const passed = this.actual === expected && deepEqual(this.actual, expected);
+    this.assert(
+      passed,
+      "toStrictEqual",
+      expected,
+      `Expected ${this.format(this.actual)} to strictly equal ${this.format(expected)}`
+    );
+  }
+  toBeTruthy() {
+    const passed = Boolean(this.actual);
+    this.assert(passed, "toBeTruthy", true, `Expected ${this.format(this.actual)} to be truthy`);
+  }
+  toBeFalsy() {
+    const passed = !Boolean(this.actual);
+    this.assert(passed, "toBeFalsy", false, `Expected ${this.format(this.actual)} to be falsy`);
+  }
+  toBeNull() {
+    const passed = this.actual === null;
+    this.assert(passed, "toBeNull", null, `Expected ${this.format(this.actual)} to be null`);
+  }
+  toBeUndefined() {
+    const passed = this.actual === void 0;
+    this.assert(
+      passed,
+      "toBeUndefined",
+      void 0,
+      `Expected ${this.format(this.actual)} to be undefined`
+    );
+  }
+  toBeDefined() {
+    const passed = this.actual !== void 0;
+    this.assert(
+      passed,
+      "toBeDefined",
+      "defined",
+      `Expected ${this.format(this.actual)} to be defined`
+    );
+  }
+  toBeNaN() {
+    const passed = Number.isNaN(this.actual);
+    this.assert(passed, "toBeNaN", NaN, `Expected ${this.format(this.actual)} to be NaN`);
+  }
+  toBeInstanceOf(constructor) {
+    const passed = this.actual instanceof constructor;
+    this.assert(
+      passed,
+      "toBeInstanceOf",
+      constructor,
+      `Expected ${this.format(this.actual)} to be instance of ${constructor.name}`
+    );
+  }
+  toBeCloseTo(expected, precision = 2) {
+    if (typeof this.actual !== "number" || typeof expected !== "number") {
+      throw new AssertionError("Expected both values to be numbers");
+    }
+    const diff = Math.abs(this.actual - expected);
+    const passed = diff < Math.pow(10, -precision) / 2;
+    this.assert(
+      passed,
+      "toBeCloseTo",
+      expected,
+      `Expected ${this.actual} to be close to ${expected} (precision: ${precision})`
+    );
+  }
+  toMatch(expected) {
+    if (typeof this.actual !== "string") {
+      throw new AssertionError("Expected value to be a string");
+    }
+    const regex = typeof expected === "string" ? new RegExp(expected) : expected;
+    const passed = regex.test(this.actual);
+    this.assert(passed, "toMatch", expected, `Expected "${this.actual}" to match ${expected}`);
+  }
+  toContain(expected) {
+    let passed = false;
+    if (typeof this.actual === "string" && typeof expected === "string") {
+      passed = this.actual.includes(expected);
+    } else if (Array.isArray(this.actual)) {
+      passed = this.actual.includes(expected);
+    } else if (this.actual && typeof this.actual.has === "function") {
+      passed = this.actual.has(expected);
+    }
+    this.assert(
+      passed,
+      "toContain",
+      expected,
+      `Expected ${this.format(this.actual)} to contain ${this.format(expected)}`
+    );
+  }
+  toHaveLength(expected) {
+    if (this.actual == null || typeof this.actual.length !== "number") {
+      throw new AssertionError("Expected value to have a length property");
+    }
+    const passed = this.actual.length === expected;
+    this.assert(
+      passed,
+      "toHaveLength",
+      expected,
+      `Expected length ${this.actual.length} to be ${expected}`
+    );
+  }
+  toContainEqual(expected) {
+    if (!Array.isArray(this.actual)) {
+      throw new AssertionError("Expected value to be an array");
+    }
+    const passed = this.actual.some((item) => deepEqual(item, expected));
+    this.assert(
+      passed,
+      "toContainEqual",
+      expected,
+      `Expected array to contain equal to ${this.format(expected)}`
+    );
+  }
+  toHaveProperty(path, value) {
+    const keys = path.split(".");
+    let current = this.actual;
+    for (const key of keys) {
+      if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {
+        this.assert(false, "toHaveProperty", path, `Expected object to have property "${path}"`);
+        return;
+      }
+      current = current[key];
+    }
+    if (value !== void 0) {
+      const passed = deepEqual(current, value);
+      this.assert(
+        passed,
+        "toHaveProperty",
+        value,
+        `Expected property "${path}" to have value ${this.format(value)}, got ${this.format(current)}`
+      );
+    } else {
+      this.assert(true, "toHaveProperty", path, "");
+    }
+  }
+  toMatchObject(expected) {
+    if (typeof this.actual !== "object" || this.actual === null) {
+      throw new AssertionError("Expected value to be an object");
+    }
+    const passed = Object.keys(expected).every(
+      (key) => deepEqual(this.actual[key], expected[key])
+    );
+    this.assert(
+      passed,
+      "toMatchObject",
+      expected,
+      `Expected object to match ${this.format(expected)}`
+    );
+  }
+  // DOM-specific matchers
+  toBeInTheDocument() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = isInDocument(this.actual);
+    this.assert(
+      passed,
+      "toBeInTheDocument",
+      "in document",
+      "Expected element to be in the document"
+    );
+  }
+  toBeVisible() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = isVisible(this.actual);
+    this.assert(passed, "toBeVisible", "visible", "Expected element to be visible");
+  }
+  toBeDisabled() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.disabled === true || this.actual.hasAttribute("disabled");
+    this.assert(passed, "toBeDisabled", "disabled", "Expected element to be disabled");
+  }
+  toBeEnabled() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.disabled !== true && !this.actual.hasAttribute("disabled");
+    this.assert(passed, "toBeEnabled", "enabled", "Expected element to be enabled");
+  }
+  toBeChecked() {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.checked === true;
+    this.assert(passed, "toBeChecked", "checked", "Expected element to be checked");
+  }
+  toHaveClass(className) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const passed = this.actual.classList.contains(className);
+    this.assert(passed, "toHaveClass", className, `Expected element to have class "${className}"`);
+  }
+  toHaveAttribute(name, value) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    if (value === void 0) {
+      const passed = this.actual.hasAttribute(name);
+      this.assert(
+        passed,
+        "toHaveAttribute",
+        `attribute "${name}"`,
+        `Expected element to have attribute "${name}"`
+      );
+    } else {
+      const passed = this.actual.getAttribute(name) === value;
+      this.assert(
+        passed,
+        "toHaveAttribute",
+        `${name}="${value}"`,
+        `Expected element to have attribute "${name}" with value "${value}"`
+      );
+    }
+  }
+  toHaveTextContent(text) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const textContent = this.actual.textContent || "";
+    const passed = typeof text === "string" ? textContent === text : text.test(textContent);
+    this.assert(
+      passed,
+      "toHaveTextContent",
+      text,
+      `Expected element to have text content "${text}"`
+    );
+  }
+  toHaveValue(value) {
+    if (!(this.actual instanceof Element)) {
+      throw new AssertionError("Expected value to be a DOM element");
+    }
+    const actualValue = this.actual.value;
+    const passed = actualValue === value;
+    this.assert(
+      passed,
+      "toHaveValue",
+      value,
+      `Expected element to have value "${value}", got "${actualValue}"`
+    );
+  }
+  // HyperScript-specific matchers
+  toHaveCompiledScript() {
+    const passed = this.actual && typeof this.actual._hyperscript !== "undefined";
+    this.assert(
+      passed,
+      "toHaveCompiledScript",
+      "compiled script",
+      "Expected element to have compiled hyperscript"
+    );
+  }
+  toHaveExecutedScript() {
+    const passed = this.actual && this.actual._hyperscriptExecuted === true;
+    this.assert(
+      passed,
+      "toHaveExecutedScript",
+      "executed script",
+      "Expected hyperscript to have executed"
+    );
+  }
+  toHaveTriggeredEvent(eventType) {
+    const passed = this.actual && this.actual._triggeredEvents && this.actual._triggeredEvents.includes(eventType);
+    this.assert(
+      passed,
+      "toHaveTriggeredEvent",
+      eventType,
+      `Expected event "${eventType}" to have been triggered`
+    );
+  }
+  toHaveUpdatedElement() {
+    const passed = this.actual && this.actual._wasUpdated === true;
+    this.assert(
+      passed,
+      "toHaveUpdatedElement",
+      "updated element",
+      "Expected element to have been updated"
+    );
+  }
+  assert(passed, operator, expected, message) {
+    if (this.isNot) {
+      passed = !passed;
+      message = message.replace("Expected", "Expected NOT");
+    }
+    if (!passed) {
+      const error = new AssertionError(message, expected, this.actual, operator);
+      if (typeof this.actual === "object" && typeof expected === "object") {
+        error.message += "\n\nDiff:\n" + generateDiff(this.actual, expected);
+      }
+      throw error;
+    }
+  }
+  format(value) {
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    if (typeof value === "string") return `"${value}"`;
+    if (typeof value === "function") return value.name || "function";
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof RegExp) return value.toString();
+    if (Array.isArray(value)) return `[${value.map((v) => this.format(v)).join(", ")}]`;
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  }
+  isPromise(value) {
+    return value && typeof value.then === "function";
+  }
+};
+function createExpectAPI() {
+  return function expect(actual) {
+    return new ExpectMatcherImpl(actual);
+  };
+}
+var AssertAPIImpl = class {
+  ok(value, message) {
+    if (!value) {
+      throw new AssertionError(message || `Expected ${value} to be truthy`);
+    }
+  }
+  equal(actual, expected, message) {
+    if (actual != expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to equal ${expected}`,
+        expected,
+        actual,
+        "equal"
+      );
+    }
+  }
+  strictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to strictly equal ${expected}`,
+        expected,
+        actual,
+        "strictEqual"
+      );
+    }
+  }
+  notEqual(actual, expected, message) {
+    if (actual == expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to not equal ${expected}`,
+        expected,
+        actual,
+        "notEqual"
+      );
+    }
+  }
+  notStrictEqual(actual, expected, message) {
+    if (actual === expected) {
+      throw new AssertionError(
+        message || `Expected ${actual} to not strictly equal ${expected}`,
+        expected,
+        actual,
+        "notStrictEqual"
+      );
+    }
+  }
+  throws(fn, error, message) {
+    let thrown = false;
+    let actualError;
+    try {
+      fn();
+    } catch (e) {
+      thrown = true;
+      actualError = e;
+    }
+    if (!thrown) {
+      throw new AssertionError(message || "Expected function to throw");
+    }
+    if (error && !this.matchesError(actualError, error)) {
+      throw new AssertionError(
+        message || `Expected function to throw ${error}, but got ${actualError}`,
+        error,
+        actualError,
+        "throws"
+      );
+    }
+  }
+  doesNotThrow(fn, message) {
+    try {
+      fn();
+    } catch (e) {
+      throw new AssertionError(
+        message || `Expected function to not throw, but got: ${e}`,
+        "no error",
+        e,
+        "doesNotThrow"
+      );
+    }
+  }
+  ifError(value) {
+    if (value) {
+      throw value;
+    }
+  }
+  async rejects(promise, error, message) {
+    let rejected = false;
+    let actualError;
+    try {
+      await promise;
+    } catch (e) {
+      rejected = true;
+      actualError = e;
+    }
+    if (!rejected) {
+      throw new AssertionError(message || "Expected promise to reject");
+    }
+    if (error && !this.matchesError(actualError, error)) {
+      throw new AssertionError(
+        message || `Expected promise to reject with ${error}, but got ${actualError}`,
+        error,
+        actualError,
+        "rejects"
+      );
+    }
+  }
+  async doesNotReject(promise, message) {
+    try {
+      await promise;
+    } catch (e) {
+      throw new AssertionError(
+        message || `Expected promise to not reject, but got: ${e}`,
+        "no error",
+        e,
+        "doesNotReject"
+      );
+    }
+  }
+  elementExists(selector, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(message || `Expected element with selector "${selector}" to exist`);
+    }
+  }
+  elementVisible(selector, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (!isVisible(element)) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to be visible`
+      );
+    }
+  }
+  elementHasClass(selector, className, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (!element.classList.contains(className)) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to have class "${className}"`
+      );
+    }
+  }
+  elementHasText(selector, text, message) {
+    if (typeof document === "undefined") {
+      throw new AssertionError("DOM not available");
+    }
+    const element = document.querySelector(selector);
+    if (!element) {
+      throw new AssertionError(`Element with selector "${selector}" does not exist`);
+    }
+    if (element.textContent !== text) {
+      throw new AssertionError(
+        message || `Expected element with selector "${selector}" to have text "${text}"`
+      );
+    }
+  }
+  scriptCompiled(script, message) {
+    throw new AssertionError(message || "Script compilation assertion not implemented");
+  }
+  scriptExecuted(script, message) {
+    throw new AssertionError(message || "Script execution assertion not implemented");
+  }
+  eventTriggered(eventType, message) {
+    throw new AssertionError(message || "Event trigger assertion not implemented");
+  }
+  matchesError(actual, expected) {
+    if (typeof expected === "string") {
+      return actual.message === expected;
+    }
+    if (expected instanceof RegExp) {
+      return expected.test(actual.message);
+    }
+    if (typeof expected === "function") {
+      return actual instanceof expected;
+    }
+    return actual === expected;
+  }
+};
+function createAssertAPI() {
+  return new AssertAPIImpl();
+}
+
+export { AssertionError, createAssertAPI, createExpectAPI };
+//# sourceMappingURL=assertions.mjs.map
+//# sourceMappingURL=assertions.mjs.map