@trackunit/react-core-contexts-test 0.0.3

package/ApolloMockedProviderWithError.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function ApolloMockedProviderWithError(props: any): JSX.Element;

package/HookRenderer.d.ts

@@ -0,0 +1,3 @@
+import { Renderer, RenderHookResult } from "@testing-library/react-hooks/pure";
+import * as React from "react";
+export declare const reactHooksRenderHook: <TProps, TResult>(callback: (props: TProps) => TResult, getMockedCompositionRoot: (children: React.ReactElement) => React.ReactElement) => Promise<RenderHookResult<TProps, TResult, Renderer<TProps>>>;

package/HookRenderer.js

@@ -0,0 +1,37 @@
+import { _ as __awaiter, f as flushPromises } from './index2.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { renderHook } from '@testing-library/react-hooks/pure';
+import { act } from 'react-test-renderer';
+import '@testing-library/react';
+import '@trackunit/react-core-contexts-api';
+import '@trackunit/react-core-hooks';
+import '@trackunit/ui-theme';
+import 'react-router-dom';
+import '@apollo/client';
+import '@apollo/client/link/error';
+import '@apollo/client/testing';
+
+const reactHooksRenderHook = (callback, getMockedCompositionRoot) => __awaiter(void 0, void 0, void 0, function* () {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const wrapper = ({
+    children
+  }) => {
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    return getMockedCompositionRoot(jsx(Fragment, {
+      children: children
+    }));
+  };
+
+  let renderedHook; // This is added here to make storybook work and to ensure the right act is loaded for hooks.
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+
+  yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+    renderedHook = renderHook(callback, {
+      wrapper
+    });
+    yield flushPromises();
+  }));
+  return renderedHook;
+});
+
+export { reactHooksRenderHook };

package/MockContextProviderBuilder.d.ts

@@ -0,0 +1,76 @@
+import { MockedResponse } from "@apollo/client/testing";
+import { RenderResult } from "@testing-library/react";
+import { ICurrentUserContext, IEnvironmentContext, IFeature, ITokenContext, UserSubscriptionPackageType } from "@trackunit/react-core-contexts-api";
+import * as React from "react";
+import { MemoryRouterProps } from "react-router-dom";
+/**
+ * This builder allows you to enable providers using the builder pattern, and then call 1 of either:
+ * - render
+ * - mount
+ */
+export declare class MockContextProviderBuilder {
+    protected selectedEnvironmentContext: IEnvironmentContext;
+    protected selectedTokenContext: ITokenContext;
+    protected userSubscriptionPackageType: UserSubscriptionPackageType;
+    protected features: IFeature[];
+    protected selectedApolloMocks: MockedResponse[];
+    protected selectedRouterProps: MemoryRouterProps;
+    protected selectedAssumedUser: ICurrentUserContext["assumedUser"];
+    /**
+     * Use this Environment Context.
+     *
+     * @param environmentContext
+     */
+    environment(environmentContext?: IEnvironmentContext): this;
+    /**
+     * Use this token.
+     *
+     * @param token
+     */
+    token(token: string): this;
+    /**
+     * Use this to pass in userSubscriptionPackage.
+     *
+     * @param developerSettingsContext
+     */
+    userSubscriptionPackage(userSubscriptionPackage?: UserSubscriptionPackageType): this;
+    /**
+     * Use this to pass in SupportedFeatures.
+     *
+     * @param developerSettingsContext
+     */
+    supportedFeatures(features?: string[]): this;
+    /**
+     * Assume this user
+     *
+     * @param assumeUser
+     */
+    assumeUser(assumeUser: ICurrentUserContext["assumedUser"]): this;
+    /**
+     * Use this Router Props with the given mocks.
+     *
+     * @param routerProps
+     */
+    routerProps(routerProps?: MemoryRouterProps): this;
+    renderHook<TProps, TResult>(callback: (props: TProps) => TResult, parentElement?: (children: React.ReactElement) => React.ReactElement): Promise<import("@testing-library/react-hooks/pure").RenderHookResult<TProps, TResult, import("@testing-library/react-hooks/pure").Renderer<TProps>>>;
+    /**
+     * Use this Manager Apollo Context Provider with the given mocks.
+     *
+     * @param apolloMocks
+     */
+    apollo(apolloMocks?: MockedResponse[]): this;
+    /**
+     * This will use RTL.render the child in the correct mocked hierarchy of context providers.
+     *
+     * @param child - the child element being tested.
+     */
+    render(child: React.ReactElement): Promise<RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>>;
+    /**
+     * Make sure this represent the same structure as the main index.tsx does.
+     *
+     * @param testChildren - the child element being tested.
+     * @param addTestRootContainer - if you want to add a root container to the test.
+     */
+    protected getMockedCompositionRoot(testChildren: React.ReactNode, addTestRootContainer?: boolean): JSX.Element;
+}
+export declare const rootContext: () => MockContextProviderBuilder;

package/README.md

@@ -0,0 +1,5 @@
+This is the documentation for library
+
+# core-contexts-test
+
+The purpose of this library is to contain the

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./MockContextProviderBuilder";
+export * from "./mocks/mockEnvironmentContext";
+export * from "./utils/doNothing";
+export * from "./utils/queryFor";

package/index.js

@@ -0,0 +1,10 @@
+export { M as MockContextProviderBuilder, d as doNothing, m as mockEnvironmentContext, q as queryFor, r as rootContext } from './index2.js';
+import 'react/jsx-runtime';
+import '@testing-library/react';
+import '@trackunit/react-core-contexts-api';
+import '@trackunit/react-core-hooks';
+import '@trackunit/ui-theme';
+import 'react-router-dom';
+import '@apollo/client';
+import '@apollo/client/link/error';
+import '@apollo/client/testing';