@lytjs/plugin-testing 6.4.0

package/dist/index.js

@@ -0,0 +1,487 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { definePlugin } from "@lytjs/core";
+function createMockFn(options = {}) {
+  let returnValue = void 0;
+  let implementation = options.implementation;
+  const calls = [];
+  const mockFn = ((...args) => {
+    calls.push(args);
+    if (implementation) {
+      return implementation(...args);
+    }
+    return returnValue;
+  });
+  Object.defineProperties(mockFn, {
+    callCount: {
+      get: () => calls.length
+    },
+    calls: {
+      get: () => [...calls]
+    },
+    lastCall: {
+      get: () => calls[calls.length - 1]
+    },
+    originalFn: {
+      get: () => options.preserveOriginal ? void 0 : void 0
+    }
+  });
+  mockFn.mockReturnValue = (value) => {
+    returnValue = value;
+  };
+  mockFn.mockImplementation = (fn) => {
+    implementation = fn;
+  };
+  mockFn.mockReset = () => {
+    calls.length = 0;
+    returnValue = void 0;
+    implementation = void 0;
+  };
+  mockFn.mockClear = () => {
+    calls.length = 0;
+  };
+  return mockFn;
+}
+function createDOMTestHelpers() {
+  const getElement = (selectorOrElement) => {
+    if (typeof selectorOrElement === "string") {
+      const el = document.querySelector(selectorOrElement);
+      if (!el) {
+        throw new Error(`Element not found: ${selectorOrElement}`);
+      }
+      return el;
+    }
+    return selectorOrElement;
+  };
+  return {
+    waitForElement: async (selector, timeout = 5e3) => {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        const el = document.querySelector(selector);
+        if (el) {
+          return el;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      throw new Error(`Element not found within timeout: ${selector}`);
+    },
+    waitForElementToDisappear: async (selector, timeout = 5e3) => {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        const el = document.querySelector(selector);
+        if (!el) {
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      throw new Error(`Element did not disappear within timeout: ${selector}`);
+    },
+    waitForText: async (text, timeout = 5e3) => {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        const el = Array.from(document.body.querySelectorAll("*")).find(
+          (el2) => el2.textContent?.includes(text)
+        );
+        if (el) {
+          return el;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      throw new Error(`Text not found within timeout: ${text}`);
+    },
+    fillForm: (data) => {
+      for (const [name, value] of Object.entries(data)) {
+        const el = document.querySelector(`[name="${name}"]`);
+        if (el) {
+          if (typeof value === "boolean" && "checked" in el) {
+            el.checked = value;
+            el.dispatchEvent(new Event("change", { bubbles: true }));
+          } else if ("value" in el) {
+            el.value = String(value);
+            el.dispatchEvent(new Event("input", { bubbles: true }));
+            el.dispatchEvent(new Event("change", { bubbles: true }));
+          }
+        }
+      }
+    },
+    click: (selectorOrElement) => {
+      const el = getElement(selectorOrElement);
+      el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    },
+    exists: (selector) => {
+      return document.querySelector(selector) !== null;
+    },
+    isVisible: (selectorOrElement) => {
+      const el = getElement(selectorOrElement);
+      const style = window.getComputedStyle(el);
+      return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+    },
+    isDisabled: (selectorOrElement) => {
+      const el = getElement(selectorOrElement);
+      return "disabled" in el && el.disabled;
+    },
+    text: (selectorOrElement) => {
+      const el = getElement(selectorOrElement);
+      return el.textContent || "";
+    },
+    attribute: (selectorOrElement, name) => {
+      const el = getElement(selectorOrElement);
+      return el.getAttribute(name);
+    },
+    classes: (selectorOrElement) => {
+      const el = getElement(selectorOrElement);
+      return Array.from(el.classList);
+    },
+    hasClass: (selectorOrElement, className) => {
+      const el = getElement(selectorOrElement);
+      return el.classList.contains(className);
+    }
+  };
+}
+function createSignalTestHelpers() {
+  return {
+    trackUpdates: (signal) => {
+      const history = [signal.value];
+      let updateCount = 0;
+      let currentValue = signal.value;
+      const originalDescriptor = Object.getOwnPropertyDescriptor(signal, "value");
+      Object.defineProperty(signal, "value", {
+        get() {
+          return currentValue;
+        },
+        set(newValue) {
+          history.push(newValue);
+          updateCount++;
+          currentValue = newValue;
+        },
+        enumerable: originalDescriptor?.enumerable ?? true,
+        configurable: true
+      });
+      return {
+        get value() {
+          return currentValue;
+        },
+        set value(newValue) {
+          history.push(newValue);
+          updateCount++;
+          currentValue = newValue;
+        },
+        get updateCount() {
+          return updateCount;
+        },
+        get history() {
+          return [...history];
+        }
+      };
+    },
+    waitForUpdate: async (signal, timeout = 5e3) => {
+      const initialValue = signal.value;
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        if (signal.value !== initialValue) {
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      throw new Error("Signal did not update within timeout");
+    }
+  };
+}
+function createFuzzTestHelpers() {
+  const randomString = (options = {}) => {
+    const maxLength = options.maxLength ?? 100;
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?";
+    const length = Math.floor(Math.random() * maxLength) + 1;
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  };
+  const randomNumber = (options = {}) => {
+    const min = options.min ?? -1e3;
+    const max = options.max ?? 1e3;
+    return Math.random() * (max - min) + min;
+  };
+  const randomBoolean = () => {
+    return Math.random() < 0.5;
+  };
+  const randomArray = (generator, options = {}) => {
+    const maxLength = options.maxLength ?? 20;
+    const length = Math.floor(Math.random() * maxLength) + 1;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push(generator());
+    }
+    return result;
+  };
+  const randomObject = (options = {}) => {
+    const maxLength = options.maxLength ?? 10;
+    const length = Math.floor(Math.random() * maxLength) + 1;
+    const result = {};
+    for (let i = 0; i < length; i++) {
+      const key = `key_${i}`;
+      const type = Math.random();
+      if (type < 0.3) {
+        result[key] = randomString({ maxLength: 20 });
+      } else if (type < 0.6) {
+        result[key] = randomNumber({ min: -100, max: 100 });
+      } else if (type < 0.8) {
+        result[key] = randomBoolean();
+      } else {
+        result[key] = null;
+      }
+    }
+    return result;
+  };
+  const randomDate = (options = {}) => {
+    const now = Date.now();
+    const offset = Math.floor(Math.random() * 1e10) - 5e9;
+    return new Date(now + offset);
+  };
+  const fuzz = async (generator, testFn, iterations = 100) => {
+    const failedCases = [];
+    let passedCases = 0;
+    for (let i = 0; i < iterations; i++) {
+      const input = generator();
+      try {
+        await testFn(input);
+        passedCases++;
+      } catch (error) {
+        failedCases.push({
+          input,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return {
+      totalCases: iterations,
+      passedCases,
+      failedCases,
+      success: failedCases.length === 0
+    };
+  };
+  return {
+    randomString,
+    randomNumber,
+    randomBoolean,
+    randomArray,
+    randomObject,
+    randomDate,
+    fuzz
+  };
+}
+function createPerformanceTestHelpers() {
+  const benchmarks = /* @__PURE__ */ new Map();
+  const benchmark = async (name, fn, options = {}) => {
+    const iterations = options.iterations ?? 1e3;
+    const warmupIterations = options.warmupIterations ?? 100;
+    for (let i = 0; i < warmupIterations; i++) {
+      await fn();
+    }
+    const times = [];
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+      const iterStart = performance.now();
+      await fn();
+      times.push(performance.now() - iterStart);
+    }
+    const totalTime = performance.now() - start;
+    const averageTime = totalTime / iterations;
+    const minTime = Math.min(...times);
+    const maxTime = Math.max(...times);
+    const opsPerSecond = 1e3 / averageTime;
+    const result = {
+      name,
+      totalTime,
+      averageTime,
+      minTime,
+      maxTime,
+      iterations,
+      opsPerSecond
+    };
+    benchmarks.set(name, result);
+    if (options.verbose) {
+      console.log(`Benchmark "${name}":`);
+      console.log(`  Average: ${averageTime.toFixed(4)}ms`);
+      console.log(`  Min: ${minTime.toFixed(4)}ms`);
+      console.log(`  Max: ${maxTime.toFixed(4)}ms`);
+      console.log(`  Ops/s: ${opsPerSecond.toFixed(2)}`);
+    }
+    return result;
+  };
+  const compare = (baseline, current) => {
+    const percentChange = (current.averageTime - baseline.averageTime) / baseline.averageTime * 100;
+    return {
+      percentChange,
+      isFaster: percentChange < 0,
+      isSlower: percentChange > 0
+    };
+  };
+  const regressionTest = async (name, fn, baseline, options = {}) => {
+    const threshold = options.threshold ?? 10;
+    const current = await benchmark(name, fn);
+    const { percentChange, isSlower } = compare(baseline, current);
+    let message = "";
+    if (isSlower && percentChange > threshold) {
+      message = `Performance regression detected: ${percentChange.toFixed(2)}% slower (threshold: ${threshold}%)`;
+    } else if (isSlower) {
+      message = `Performance slightly slower: ${percentChange.toFixed(2)}% (within threshold)`;
+    } else if (percentChange < 0) {
+      message = `Performance improved: ${Math.abs(percentChange).toFixed(2)}% faster`;
+    } else {
+      message = "Performance unchanged";
+    }
+    return {
+      passed: !isSlower || percentChange <= threshold,
+      baseline,
+      current,
+      regressionPercent: percentChange,
+      message
+    };
+  };
+  const saveBaseline = (result, path = "./benchmarks") => {
+    try {
+      if (typeof window === "undefined") {
+        const fs = __require("fs");
+        const fspath = __require("path");
+        if (!fs.existsSync(path)) {
+          fs.mkdirSync(path, { recursive: true });
+        }
+        const filePath = fspath.join(path, `${result.name}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(result, null, 2));
+      }
+    } catch (e) {
+      console.warn("Could not save baseline:", e);
+    }
+  };
+  const loadBaseline = (name, path = "./benchmarks") => {
+    try {
+      if (typeof window === "undefined") {
+        const fs = __require("fs");
+        const fspath = __require("path");
+        const filePath = fspath.join(path, `${name}.json`);
+        if (fs.existsSync(filePath)) {
+          return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+      }
+    } catch (e) {
+      console.warn("Could not load baseline:", e);
+    }
+    return null;
+  };
+  return {
+    benchmark,
+    compare,
+    regressionTest,
+    saveBaseline,
+    loadBaseline
+  };
+}
+function createTestingContext(options = {}) {
+  const mocks = /* @__PURE__ */ new Map();
+  const mockFns = [];
+  const domHelpers = createDOMTestHelpers();
+  const signalHelpers = createSignalTestHelpers();
+  const fuzzHelpers = createFuzzTestHelpers();
+  const performanceHelpers = createPerformanceTestHelpers();
+  return {
+    mount: (component, options2 = {}) => {
+      const container = typeof options2.container === "string" ? document.querySelector(options2.container) : options2.container || document.createElement("div");
+      if (!container) {
+        throw new Error("Invalid container");
+      }
+      if (options2.attach !== false && container.parentNode === null) {
+        document.body.appendChild(container);
+      }
+      let instance = {};
+      const element = container;
+      return {
+        instance,
+        element,
+        unmount: () => {
+          while (container.firstChild) {
+            container.firstChild.remove();
+          }
+          if (options2.attach !== false && container.parentNode === document.body) {
+            document.body.removeChild(container);
+          }
+        },
+        rerender: (newProps) => {
+        },
+        find: (selector) => element.querySelector(selector),
+        findAll: (selector) => Array.from(element.querySelectorAll(selector)),
+        trigger: (eventName, payload) => {
+          element.dispatchEvent(new CustomEvent(eventName, { detail: payload }));
+        }
+      };
+    },
+    mockFn: (mockOptions) => {
+      const mockFn = createMockFn(mockOptions);
+      mockFns.push(mockFn);
+      return mockFn;
+    },
+    mockModule: (moduleName, factory) => {
+      mocks.set(moduleName, factory());
+    },
+    clearAllMocks: () => {
+      mockFns.forEach((mockFn) => mockFn.mockClear());
+      mocks.clear();
+    },
+    signal: signalHelpers,
+    dom: domHelpers,
+    fuzz: fuzzHelpers,
+    performance: performanceHelpers,
+    wait: async (ms) => {
+      await new Promise((resolve) => setTimeout(resolve, ms));
+    },
+    waitFor: async (condition, timeout = 5e3) => {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        const result = await condition();
+        if (result) {
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      throw new Error("Condition not met within timeout");
+    },
+    nextTick: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  };
+}
+var pluginTesting = definePlugin({
+  name: "testing",
+  version: "6.0.0",
+  description: "LytJS official testing plugin with testing utilities and helpers, including fuzz testing and performance regression testing",
+  author: "LytJS Team",
+  keywords: ["lytjs", "testing", "test-utilities", "fuzz-testing", "benchmark"],
+  schema: {
+    type: "object",
+    object: {
+      properties: {
+        defaultTimeout: { type: "number", default: 5e3 },
+        autoCleanup: { type: "boolean", default: true },
+        environment: { type: "string", default: "jsdom" }
+      }
+    }
+  },
+  install(app, options) {
+    const testingContext = createTestingContext(options);
+    app.config.globalProperties.$testing = testingContext;
+    app.provide("lyt-testing", testingContext);
+  }
+});
+var index_default = pluginTesting;
+export {
+  createMockFn,
+  createTestingContext,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lytjs/plugin-testing",
+  "version": "6.4.0",
+  "description": "LytJS official testing plugin with testing utilities and helpers",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@lytjs/core": "^6.4.0",
+    "@lytjs/reactivity": "^6.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/lytjs/lytjs.git",
+    "directory": "packages/plugins/packages/plugin-testing"
+  },
+  "keywords": [
+    "lytjs",
+    "testing",
+    "test-utilities"
+  ]
+}