react-antd-admin-panel/dist/testing/index.js

Modern TypeScript-first React admin panel builder with Ant Design 6

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import React from "react";
import { G as GlobalStore, U as UserState, d as MainContext } from "../MainContext-CrnhXpyN.js";
import { List } from "../list/index.js";
class MockHttp {
  constructor(config) {
    __publicField(this, "_getHandlers", /* @__PURE__ */ new Map());
    __publicField(this, "_postHandlers", /* @__PURE__ */ new Map());
    __publicField(this, "_defaultDelay", 0);
    /**
     * Get the mock GET handler function
     */
    __publicField(this, "get", async (url, params) => {
      return this._handleRequest(this._getHandlers, url, params);
    });
    /**
     * Get the mock POST handler function
     */
    __publicField(this, "post", async (url, data) => {
      return this._handleRequest(this._postHandlers, url, data);
    });
    this._defaultDelay = (config == null ? void 0 : config.defaultDelay) || 0;
  }
  /**
   * Register a mock GET response
   */
  onGet(url, response) {
    this._getHandlers.set(url, response);
    return this;
  }
  /**
   * Register a mock POST response
   */
  onPost(url, response) {
    this._postHandlers.set(url, response);
    return this;
  }
  /**
   * Clear all registered handlers
   */
  clear() {
    this._getHandlers.clear();
    this._postHandlers.clear();
    return this;
  }
  /**
   * Internal request handler
   */
  async _handleRequest(handlers, url, _data) {
    const response = handlers.get(url);
    if (!response) {
      throw new Error(`No mock handler registered for ${url}`);
    }
    const delay = response.delay ?? this._defaultDelay;
    if (delay > 0) {
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
    if (response.error) {
      throw response.error;
    }
    return {
      data: response.data,
      status: response.status ?? 200
    };
  }
  /**
   * Get all registered GET handlers (for inspection in tests)
   */
  getRegisteredGetHandlers() {
    return Array.from(this._getHandlers.keys());
  }
  /**
   * Get all registered POST handlers (for inspection in tests)
   */
  getRegisteredPostHandlers() {
    return Array.from(this._postHandlers.keys());
  }
}
function createMockHttp(config) {
  return new MockHttp(config);
}
function createMockMain(options = {}) {
  const store = new GlobalStore();
  const userState = new UserState();
  const mockHttp = createMockHttp();
  if (options.store) {
    for (const [key, value] of Object.entries(options.store)) {
      store.set(key, value);
    }
  }
  if (options.user) {
    userState.set(options.user);
  }
  const calls = [];
  const mockNavigate = Object.assign(
    (...args) => {
      calls.push(args);
    },
    {
      mock: { calls },
      mockClear: () => {
        calls.length = 0;
      }
    }
  );
  const config = options.config || {};
  const mainInstance = {
    User: () => userState,
    Store: () => store,
    config: {
      pathToApi: config.pathToApi || "/api",
      defaultRoute: config.defaultRoute || "/",
      authRoute: config.authRoute || "/login",
      ...config
    },
    navigate: mockNavigate,
    canAccess: (route) => {
      if (route.requiredRole && !userState.hasRole(route.requiredRole)) {
        return false;
      }
      if (route.requiredPermissions && !userState.hasAllPermissions(route.requiredPermissions)) {
        return false;
      }
      return true;
    }
  };
  const wrapper = ({ children }) => {
    return React.createElement(
      MainContext.Provider,
      { value: mainInstance },
      children
    );
  };
  return {
    wrapper,
    mockNavigate,
    mockHttp,
    mainInstance,
    userState,
    store
  };
}
function createMockList(options = {}) {
  const list = new List();
  if (options.rowKey) {
    list.rowKey(options.rowKey);
  } else {
    list.rowKey("id");
  }
  if (options.empty) {
    list.dataSource([]);
  } else if (options.data) {
    list.dataSource(options.data);
  }
  if (options.loading !== void 0) {
    list.loading(options.loading);
  }
  if (options.pagination !== void 0) {
    list.pagination(options.pagination);
  }
  if (options.emptyText) {
    list.emptyText(options.emptyText);
  }
  return list;
}
export {
  MockHttp,
  createMockHttp,
  createMockList,
  createMockMain
};
//# sourceMappingURL=index.js.map