@equinor/fusion-framework-vitest-plugin-react-app 1.0.0 → 1.0.2

package/src/test-app.tsx

@@ -1,148 +0,0 @@
-import type { ReactElement } from 'react';
-import { test as baseTest } from 'vitest';
-import { render, renderHook } from 'vitest-browser-react';
-import type { RenderOptions, RenderHookOptions } from 'vitest-browser-react';
-
-import { mockAppModules } from '@equinor/fusion-framework-app/mock';
-import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
-import type { AppEnv } from '@equinor/fusion-framework-app';
-import type { AppModule } from '@equinor/fusion-framework-module-app';
-import type { NavigationModule } from '@equinor/fusion-framework-module-navigation';
-import type { FrameworkMockConfigureFn } from '@equinor/fusion-framework/mock';
-
-import { defaultAppEnv, resolveFusion, createAppScopeWrapper } from './scope';
-
-/**
- * `vitest`'s `test`, extended with an application module scope fixture.
- *
- * @remarks
- * An alternative to {@link renderAppComponent}/{@link renderAppHook} for a test file whose
- * cases share seeded fixture defaults: `appEnv`/`configureApp` become suite-level concerns,
- * overridden once per file (or per `describe` block) with `testApp.extend(...)`, rather than
- * an options object repeated on every call. `fusion`/`app` are still instantiated fresh per
- * test — only the seeded defaults are shared, not state between tests. They also resolve
- * lazily: a test that only destructures `app` never pays for rendering anything, and one
- * that only destructures `render`/`renderHook` gets the same fixture wiring automatically.
- *
- * Both entry points stay supported: reach for `renderAppComponent`/`renderAppHook` for a
- * one-off test whose configuration is not shared by the rest of the file; reach for
- * `testApp` when several cases in a file share one set of seeded fixture defaults.
- *
- * @remarks `configureApp`/`configureFusion` default to `undefined` here
- * Unlike `@equinor/fusion-framework-vitest-plugin-react-app/test`'s `test`, this `testApp` does
- * not resolve the app's real `src/config.ts` — it requires `appTestVitePlugin`'s Vite virtual
- * modules to load that file as live code, which `testApp` (no Vite dependency) cannot do. Extend
- * `test` from `/test` instead when a suite needs to compose with the app's real configuration.
- *
- * @remarks Overriding `fusion` bypasses `configureFusion`
- * `fusion` and `configureFusion` are not independent: `fusion`'s default resolver is what
- * calls `configureFusion`. `.override('fusion', ...)` replaces that resolver outright, so a
- * `configureFusion` override on the same test/suite is silently never called. Use
- * `configureFusion` to extend the base framework mock; use `fusion` only to replace it
- * entirely (e.g. with a fully custom or non-mocked instance).
- *
- * @example
- * ```tsx
- * testApp('resolves current context', async ({ app, render }) => {
- *   const screen = await render(<App />);
- *   expect(app.context).toBeDefined();
- * });
- * ```
- *
- * @example Seed a module for every test in a suite
- * ```tsx
- * describe('with a seeded context module', () => {
- *   const test = testApp.extend(
- *     'configureApp',
- *     { injected: true },
- *     (): AppMockConfigureFn =>
- *       (configurator) =>
- *         enableContextMock(configurator, (mock) => mock.setCurrentContext(projectA)),
- *   );
- *
- *   test('starts on the seeded context', async ({ render }) => {
- *     const screen = await render(<App />);
- *     await expect.element(screen.getByText(projectA.title)).toBeVisible();
- *   });
- * });
- * ```
- *
- * @example Type `app`'s registered modules for consumers
- * ```tsx
- * // `configureApp`'s `TModules` generic only types that callback's own `configurator` parameter.
- * // `app`'s type was already fixed (to `unknown`) when the base `testApp` chain defined it, so a
- * // later `configureApp` override does not retroactively change what `app` is typed as. Re-extend
- * // `app` too, with the same `TModules`, to get a typed `app.navigation` in tests.
- * const test = testApp
- *   .extend(
- *     'configureApp',
- *     { injected: true },
- *     ({ configureApp }): AppMockConfigureFn<[NavigationModule]> =>
- *       async (configurator, args) => {
- *         await configureApp?.(configurator, args);
- *         enableNavigation(configurator, '/app');
- *       },
- *   )
- *   .extend('app', ({ configureApp, appEnv, fusion }) =>
- *     mockAppModules<[NavigationModule], AppEnv>(configureApp, appEnv as AppEnv, fusion),
- *   );
- *
- * test('exposes the navigation module', async ({ app }) => {
- *   expect(app.navigation).toBeDefined();
- * });
- * ```
- *
- * @example Extend the parent framework mock with an application module
- * ```tsx
- * const test = testApp.extend(
- *   'configureFusion',
- *   { injected: true },
- *   (): FrameworkMockConfigureFn<[AppModule, NavigationModule]> =>
- *     (configurator) => {
- *       // seed a specific flag rather than merely enabling the mock — that's already the
- *       // default when the optional feature-flag peer dependency is installed
- *       enableFeatureFlagMock(configurator, (mock) => mock.addFeature({ key: 'new-search', enabled: true }));
- *       configurator.serviceDiscovery.addServices([
- *         { key: 'people', uri: baseUrl('people') },
- *         { key: 'context', uri: baseUrl('context') },
- *       ]);
- *     },
- * );
- * ```
- */
-export const testApp = baseTest
-  .extend('appEnv', { injected: true }, defaultAppEnv)
-  // `test.extend`'s plain-`value` overload rejects function types (ambiguous with the
-  // resolver-`fn` overload), so a function-typed fixture default must go through `fn` instead.
-  .extend('configureApp', { injected: true }, () => undefined as AppMockConfigureFn | undefined)
-  // Runs after the built-in app manifest/navigation/feature-flag setup, so a test can register
-  // extra framework modules, service discovery entries, or call `enableNavigation`/
-  // `enableFeatureFlagMock` again to override either, without reimplementing the base setup.
-  .extend(
-    'configureFusion',
-    { injected: true },
-    () => undefined as FrameworkMockConfigureFn<[AppModule, NavigationModule]> | undefined,
-  )
-  // IMPORTANT: `.override('fusion', ...)` replaces this resolver entirely, so `configureFusion`
-  // is never called — reach for `configureFusion` to extend the base mock, `fusion` only to
-  // replace it outright (e.g. with a fully custom or non-mocked instance).
-  .extend('fusion', async ({ appEnv, configureFusion }) =>
-    resolveFusion({ env: appEnv, configure: configureFusion }),
-  )
-  .extend('app', async ({ configureApp, appEnv, fusion }) =>
-    mockAppModules<unknown, AppEnv>(configureApp, appEnv as AppEnv, fusion),
-  )
-  .extend('render', ({ fusion, app }) => {
-    const wrapper = createAppScopeWrapper({ framework: fusion, app });
-    return (ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>) =>
-      render(ui, { ...options, wrapper });
-  })
-  .extend('renderHook', ({ fusion, app }) => {
-    const wrapper = createAppScopeWrapper({ framework: fusion, app });
-    return <Result, Props = undefined>(
-      cb: (initialProps?: Props) => Result,
-      options?: Omit<RenderHookOptions<Props>, 'wrapper'>,
-    ) => renderHook(cb, { ...options, wrapper });
-  });
-
-export default testApp;

package/src/test.tsx

@@ -1,42 +0,0 @@
-import { testApp as baseTestApp } from './test-app';
-
-// resolved at test-time by `appTestVitePlugin` (@equinor/fusion-framework-vitest-plugin-react-app);
-// see virtual-modules.d.ts for the ambient module declarations
-import { manifest, config } from 'virtual:fusion-app-test-env';
-import { configure as configureApp } from 'virtual:fusion-app-test-configure';
-
-/**
- * `vitest`'s `test`, pre-seeded with the application's own manifest, config, and
- * module-configurator, resolved the same way `ffc app build`/`ffc app dev` resolve them.
- *
- * @remarks
- * Requires `appTestVitePlugin` (`@equinor/fusion-framework-vitest-plugin-react-app`) registered in
- * your `vitest.config.ts` `plugins`, which serves the virtual modules backing this fixture.
- * Running the same test file without the plugin registered fails to resolve those imports.
- *
- * Per-test mocking still works exactly like the base `testApp`: `.extend('configureApp', ...)` or
- * a per-case `test.override('appEnv', ...)` layers on top of the resolved values.
- *
- * @remarks `.override('configureApp', ...)` replaces the app's real `configure`
- * This fixture's default value *is* the app's real `src/config.ts` `configure` export.
- * `.override('configureApp', ...)` replaces that default outright, so an override that doesn't
- * itself call the real `configure(configurator, args)` skips the app's production module setup
- * entirely, rather than composing with it. See [Advanced usage](../docs/advanced.md) for the
- * compose-safely pattern.
- *
- * @example
- * ```tsx
- * import { test } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
- * import { App } from '../App';
- *
- * test('renders the app', async ({ render }) => {
- *   const screen = await render(<App />);
- *   await expect.element(screen.getByRole('heading')).toBeVisible();
- * });
- * ```
- */
-export const test = baseTestApp
-  .extend('appEnv', { injected: true }, { manifest, config })
-  .extend('configureApp', { injected: true }, () => configureApp);
-
-export default test;

package/src/version.ts

@@ -1,2 +0,0 @@
-// Generated by genversion.
-export const version = '1.0.0';

package/src/virtual-modules.d.ts

@@ -1,12 +0,0 @@
-declare module 'virtual:fusion-app-test-env' {
-  import type { AppEnv } from '@equinor/fusion-framework-app';
-
-  export const manifest: AppEnv['manifest'];
-  export const config: AppEnv['config'];
-}
-
-declare module 'virtual:fusion-app-test-configure' {
-  import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
-
-  export const configure: AppMockConfigureFn | undefined;
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "outDir": "dist/esm",
-    "rootDir": "src",
-    "declarationDir": "./dist/types",
-    "paths": {
-      "*": ["./*"]
-    }
-  },
-  "references": [
-    { "path": "../../cli" },
-    { "path": "../../framework" },
-    { "path": "../../app" },
-    { "path": "../../modules/module" },
-    { "path": "../../modules/app" },
-    { "path": "../../modules/navigation" },
-    { "path": "../../modules/feature-flag" },
-    { "path": "../../react/framework" },
-    { "path": "../../react/modules/module" },
-    { "path": "../../utils/imports" }
-  ],
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/__tests__/**/*"]
-}

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineProject } from 'vitest/config';
-
-import { name, version } from './package.json' with { type: 'json' };
-
-export default defineProject({
-  test: {
-    include: ['src/__tests__/**/*.test.ts'],
-    name: `${name}@${version}`,
-  },
-});