@equinor/fusion-framework-vitest-plugin-react-app 1.0.0-next.6 → 1.0.1

package/docs/module-mocks.md

@@ -1,120 +0,0 @@
-# Mock Fusion dependencies in app tests
-
-Use module-owned `/mock` entry points to seed deterministic Fusion state while retaining each
-module's real configurator, provider, validation, and lifecycle. Import only the boundary the
-app test needs; the React app test fixture already composes the normal framework and app
-module scopes.
-
-| App dependency | Import path | Primary API |
-| --- | --- | --- |
-| Analytics | `@equinor/fusion-framework-module-analytics/mock` | `MockAnalyticsAdapter` |
-| App manifests and config | `@equinor/fusion-framework-module-app/mock` | `MockAppClient` |
-| Browser authentication | `@equinor/fusion-framework-module-msal/mock` | `enableMsalMock`, `MsalMockClient`, `createMockToken` |
-| Node authentication with Azure Identity | `@equinor/fusion-framework-module-azure-identity/mock` | `enableAuthMock`, `MockAuthProvider` |
-| Node authentication with MSAL | `@equinor/fusion-framework-module-msal-node/mock` | `enableAuthMock`, `MockAuthProvider` |
-| Bookmarks | `@equinor/fusion-framework-module-bookmark/mock` | `enableBookmarkMock`, `BookmarkMockConfigurator` |
-| Context | `@equinor/fusion-framework-module-context/mock` | `enableContextMock`, `ContextMockConfigurator` |
-| Context fixture generation | `@equinor/fusion-framework-module-context/mock/fixtures` | `createContextItemFactory`, `createContextItems` |
-| Feature flags | `@equinor/fusion-framework-module-feature-flag/mock` | `enableFeatureFlagMock`, `FeatureFlagMockConfigurator` |
-| HTTP routes and OpenAPI responses | `@equinor/fusion-framework-module-http/mock` | `createRouterMiddleware`, `createOpenApiMockMiddleware` |
-| Service discovery | `@equinor/fusion-framework-module-service-discovery/mock` | `enableServiceDiscoveryMock`, `ServiceDiscoveryMockConfigurator` |
-| Telemetry | `@equinor/fusion-framework-module-telemetry/mock` | `enableTelemetryMock`, `MockTelemetryAdapter` |
-
-The event module has no mock entry point. `waitForEvent` and `watchEvents` from
-`@equinor/fusion-framework-module-event/utils` observe the real event provider initialized by
-the app test fixture.
-
-## Authentication
-
-App tests start with a deterministic signed-in `Test User`. Set a named account or `null`
-through `configurator.msal.setAccount(...)` before rendering. The real MSAL provider still
-runs its initialization, account, token, and logout behavior against the in-process client.
-
-See [MSAL testing](../../../modules/msal/docs/testing.md) for signed-out startup, login flows,
-deterministic JWTs, and individual client spies.
-
-## App manifest and configuration
-
-The `/test` entry point automatically resolves the current app's manifest, `app.config.ts`,
-and module configurator. Use `enableAppManifestMock` when a custom parent framework must serve
-those values, or `mockAppModules` for app module testing without React.
-
-See [Application module testing](../../../app/docs/testing.md).
-
-## Context
-
-Use `enableContextMock` for known domain state without a context API or HTTP setup. The pool
-starts empty; `setCurrentContext` seeds and selects one item, while `setContexts` only makes
-items resolvable. Use HTTP middleware instead when the context service and transport pipeline
-are part of the test.
-
-See [Context testing](../../../modules/context/README.md#testing) for defaults, related-context
-behavior, and deterministic fixture generators.
-
-## Service discovery and HTTP
-
-Use `enableServiceDiscoveryMock` to resolve services from an in-memory registry. Use
-`configurator.http.addMiddleware` to answer a few explicit requests through the app's real
-named clients. Use `createOpenApiMockMiddleware` when an OpenAPI document describes many
-operations.
-
-- [Service discovery testing](../../../modules/service-discovery/docs/testing.md)
-- [HTTP testing](../../../modules/http/docs/testing.md)
-- [OpenAPI mock](../../../utils/openapi-mock/README.md)
-
-An HTTP middleware handles only requests for which it returns a `Response`. Calling
-`next(uri, init)` delegates to the next middleware and eventually the real network.
-
-## Events, analytics, and telemetry
-
-- Observe the real event provider with `waitForEvent` or `watchEvents` from
-  `@equinor/fusion-framework-module-event/utils`.
-- Register `MockAnalyticsAdapter` to record analytics without exporting them.
-- Use `enableTelemetryMock` and assert through `MockTelemetryAdapter.getItems` or
-  `waitForItem`.
-
-- [Event testing utilities](../../../modules/event/docs/testing.md)
-- [Analytics testing](../../../modules/analytics/docs/testing.md)
-- [Telemetry testing](../../../modules/telemetry/README.md#testing)
-
-## Seed several app dependencies
-
-Compose the app's real configuration with the module mocks required by the scenario:
-
-```tsx
-import { enableContextMock } from '@equinor/fusion-framework-module-context/mock';
-import { enableFeatureFlagMock } from '@equinor/fusion-framework-module-feature-flag/mock';
-import { test as baseTest } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
-
-const project = {
-  id: 'project-a',
-  title: 'Project A',
-  type: { id: 'ProjectMaster' },
-  value: {},
-};
-
-export const test = baseTest.extend('configureApp', ({ configureApp }) => (configurator, args) => {
-  configureApp?.(configurator, args);
-  configurator.msal.setAccount({ name: 'Ada Lovelace' });
-  enableContextMock(configurator, (mock) => mock.setCurrentContext(project));
-  enableFeatureFlagMock(configurator, (mock) => {
-    mock.addFeature({ key: 'new-search', enabled: true });
-  });
-});
-```
-
-The fixture declarations are reusable, while every test still receives fresh framework and
-app module instances.
-
-## Choose direct module mocks or HTTP
-
-- Use a module mock for known domain state such as one current context, one account, or a set
-  of feature flags.
-- Use `configurator.http.addMiddleware` when the test must exercise the module's production
-  service-discovery, HTTP-client, and response-handling pipeline.
-- Use `createOpenApiMockMiddleware` when an OpenAPI document describes many operations.
-- Use Vitest `vi.fn`, `vi.spyOn`, or `vi.mock` for individual JavaScript calls rather than a
-  Fusion-specific wrapper.
-
-See each owning package README or `docs/testing.md` for its defaults, builder methods, and
-failure behavior.

package/docs/overview.md

@@ -1,49 +0,0 @@
-# Test Fusion React apps
-
-Fusion Framework uses Vitest for application tests. Vitest shares Vite's module and
-configuration model, runs components in a real browser, and owns the test runner, assertions,
-fixtures, spies, coverage, and editor integration. Fusion provides only the application scope
-and deterministic platform boundaries needed to test production behavior.
-
-Use `@equinor/fusion-framework-vitest-plugin-react-app` when a React hook, component, route,
-or complete app consumes Fusion modules. The package resolves app files, initializes the real
-framework and app provider nesting, and substitutes supported external clients without
-introducing a second testing language.
-
-## Choose the subject
-
-| Subject | Start with | What the test proves |
-| --- | --- | --- |
-| Pure function or framework-independent hook | Standard Vitest | Local behavior without a Fusion runtime |
-| Hook that consumes Fusion app modules | `renderAppHook` | Hook behavior inside an initialized app scope |
-| Component that consumes Fusion app modules | `/test` `render` fixture or `renderAppComponent` | Rendered behavior with real providers |
-| Route or complete application | `/test` `test` and `render` | App configuration, navigation, loaders, and module lifecycle together |
-| Framework or module integration without React | Package `/mock` entry points | Production provider behavior with external boundaries substituted |
-
-Prefer the smallest layer containing the behavior under assertion. A component test should
-not recreate a portal, while an app lifecycle test should not replace every Fusion hook with
-a JavaScript module mock.
-
-## Start here
-
-Follow [Getting started](getting-started.md) to install the browser dependencies, configure
-Vitest, and run one deterministic app test without credentials, a portal, or backend services.
-
-## Continue by task
-
-- [Configure Vitest defaults and non-standard app files](configuration.md)
-- [Compose fixtures and explicit render options](advanced.md)
-- [Seed Fusion module dependencies](module-mocks.md)
-- [Troubleshoot browser, app-resolution, and network failures](troubleshooting.md)
-- [Understand the Browser Mode default or choose another renderer](why-browser-mode.md)
-- [Migrate an existing app from Testing Library and DOM emulation](migrating-an-existing-app.md)
-- [Choose between app, framework, module, and HTTP testing](../../../framework/docs/testing-choosing-a-layer.md)
-
-Use the official Vitest documentation for generic runner concepts:
-
-- [Why Vitest](https://vitest.dev/guide/why)
-- [Writing tests](https://vitest.dev/guide/learn/writing-tests)
-- [Browser Mode](https://vitest.dev/guide/browser/)
-- [Test context and fixtures](https://vitest.dev/guide/test-context)
-- [Configuration](https://vitest.dev/config/)
-- [Mocking](https://vitest.dev/guide/mocking)

package/docs/troubleshooting.md

@@ -1,67 +0,0 @@
-# Troubleshoot Fusion React app tests
-
-Use this guide when a Fusion app test fails before the assertion, loads real services, cannot
-resolve the app, or behaves differently in Vitest Browser Mode.
-
-## Common symptoms
-
-| Symptom | Likely cause | Resolution |
-| --- | --- | --- |
-| Chromium executable is missing | Playwright installed without its browser binary | Run `pnpm exec playwright install chromium` |
-| The `/test` import cannot resolve Fusion virtual modules | `appTestVitePlugin` is not registered in this Vitest project | Export `defineProject()` from the package's `/config` entry point or register `appTestVitePlugin()` manually |
-| `FileNotFoundError` names a manifest, config, or configurator | An explicit plugin path does not exist | Correct the path relative to the Vitest project root; explicit paths fail instead of falling back |
-| The app's module configuration is not applied | No conventional `src/config.ts(x|js)` file was found | Pass `configure` to `appTestVitePlugin` or override the `configure` fixture |
-| A render result is a Promise or assertions run before initialization | A Fusion render helper was not awaited | Await `render`, `renderHook`, `renderAppComponent`, or `renderAppHook` |
-| A request reaches a live backend or fails with a network error | No HTTP middleware answered it | Add a matching `configurator.http.addMiddleware`; unmatched requests eventually reach the real network |
-| A lazy route import reloads the browser during a test | Source warmup no longer covers the lazy module | Keep `server.warmup.clientFiles` aligned with application source and route locations |
-| No tests are found | Tests are outside the default `src/**/*.{test,spec}.{ts,tsx}` pattern | Override `test.include` in `defineProject` |
-| The app starts signed in unexpectedly | The MSAL mock defaults to `Test User` | Set `configurator.msal.setAccount(null)` before rendering |
-| State configured in one test is missing in another | Framework and app fixtures are test-scoped | Seed the required state per test or publish reusable fixture declarations with `test.extend` |
-| `vi.spyOn` fails on an imported module in Browser Mode | Native ESM module namespace objects are sealed | Use `vi.mock('./module.js', { spy: true })` as documented by Vitest Browser Mode |
-| A `<Router>` route with a catch-all or parameterized `path` never renders; every query on it times out | The navigation module's current location does not match that path yet | Push the target location through the navigation module (`app.modules.navigation.push(path)`) before rendering, not after |
-| A virtualized list or popover (for example an EDS `Autocomplete` built on `@tanstack/react-virtual`) never renders its rows | `window.ResizeObserver` was stubbed as a no-op in test setup | Remove the stub; real Chromium's `ResizeObserver` is required for virtualized layout to measure correctly |
-| `test.each` runs but a fixture in its per-case callback is `undefined` | `test.each` does not forward `test.extend` fixture context to each case | Use Vitest's `test.for` instead, which does receive fixture context |
-
-## Verify the project wiring
-
-Start with the smallest configuration:
-
-```ts
-import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
-
-export default defineProject();
-```
-
-Then verify the fixture itself before testing application behavior:
-
-```tsx
-import { expect } from 'vitest';
-import { test } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
-
-test('initializes a Fusion app scope', async ({ app, render }) => {
-  expect(app.auth.account?.name).toBe('Test User');
-  const screen = await render(<div>ready</div>);
-  await expect.element(screen.getByText('ready')).toBeVisible();
-});
-```
-
-If this test fails, fix project or app-file resolution before adding module-specific data.
-
-## Keep tests offline
-
-Fusion mocks replace known external boundaries, but an HTTP middleware is an ordered chain.
-Returning `next(uri, init)` delegates to the next middleware and eventually `fetch`. A test
-that must never use the network should register middleware for every expected request and
-fail deliberately on unexpected requests.
-
-Use `createOpenApiMockMiddleware` from
-`@equinor/fusion-framework-module-http/mock` when an OpenAPI document describes many routes.
-Use `vi.fn` around a middleware when the test also needs call assertions.
-
-## Related references
-
-- [Getting started](getting-started.md)
-- [Configuration and app-file resolution](configuration.md)
-- [Choose a Fusion testing layer](../../../framework/docs/testing-choosing-a-layer.md)
-- [HTTP middleware testing](../../../modules/http/docs/testing.md)
-- [Vitest Browser Mode limitations](https://vitest.dev/guide/browser/#limitations)

package/docs/why-browser-mode.md

@@ -1,128 +0,0 @@
-# Why Browser Mode is the default
-
-`@equinor/fusion-framework-vitest-plugin-react-app` runs component and hook tests in headless
-Chromium by default. A real browser gives these tests more accurate DOM behavior, but it is
-slower than `happy-dom` or `jsdom`.
-
-This guide explains that tradeoff and shows how to use a different browser or renderer when a
-test does not need Chromium.
-
-## Performance
-
-A real browser is slower than DOM emulation. `happy-dom` and `jsdom` run in the same Node process
-as the test. Browser Mode starts Chromium through Playwright and communicates with that browser
-process.
-
-Choose Browser Mode for fidelity, not speed. Keep fast unit tests on Node or DOM emulation when
-they do not need browser behavior.
-
-## Why use a real browser
-
-- **React compatibility:** the previous React test setup failed after its React 19 peer
-  dependency update. The repository then moved those tests to Vitest Browser Mode. See the
-  `packages/utils/observable` 8.4.4 changelog and migration commit `059aefae5d`.
-- **Real framework execution:** tests control external boundaries and seed module state through
-  [Module mocks](module-mocks.md), while the actual module configuration, lifecycle, providers,
-  and rendering behavior still run.
-- **Browser fidelity:** Chromium provides real layout, `ResizeObserver`, custom elements, and
-  Shadow DOM — behavior `happy-dom` and `jsdom` only approximate.
-
-> [!WARNING]
-> A DOM-emulation gap is usually patched one of two ways: a polyfill standing in for the missing
-> browser API, or a component replacement that avoids exercising it at all. Both are test-only
-> code with no equivalent in production, and both defeat the point of the test: a polyfill can
-> drift from real browser behavior unnoticed, and a mocked component only proves the *mock*
-> renders correctly, never the real one. A passing test built on either can still fail — or
-> silently lie — against the real component. Treat every DOM-emulation workaround as debt to
-> remove, not a pattern to reach for.
-
-A real browser does not eliminate every workaround: AG Grid license messages and Lit dev-mode
-warnings are console noise from real Chromium runs, not DOM-emulation gaps, and suppressing them
-carries none of the risk above (see [Module mocks](module-mocks.md) for the supported way to
-seed module state instead of replacing a component). Remove a DOM-emulation-only workaround only
-after confirming the affected test still passes against the real component in Browser Mode.
-
-## Choose a different runtime
-
-You can change either the browser provider or the renderer:
-
-- Stay in Browser Mode and replace Playwright with another Vitest browser provider.
-- Keep the Fusion module setup but render with `happy-dom` or `jsdom`.
-
-### Use another browser provider
-
-Pass `test.browser.provider` to `defineProject` to replace Playwright while staying in Browser
-Mode. This example uses WebdriverIO:
-
-```ts
-import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
-import { webdriverio } from '@vitest/browser-webdriverio';
-
-export default defineProject({
-  test: { browser: { provider: webdriverio() } },
-});
-```
-
-See [Configuration](configuration.md) for the complete `defineProject` behavior.
-
-### Use happy-dom or jsdom
-
-> [!CAUTION]
-> Rendering with `happy-dom` or `jsdom` reintroduces the DOM-emulation tradeoff above: any gap
-> between the emulation and a real browser has to be closed with a polyfill or a component
-> replacement, not fixed. Only take this path for a component or hook that provably does not
-> need browser fidelity — otherwise stay in Browser Mode.
-
-The Fusion module setup does not depend on Browser Mode. Build the same provider tree and pass it
-to another renderer. The example below uses `@testing-library/react` on `happy-dom`:
-
-```tsx
-import { render } from '@testing-library/react';
-import { mockFramework } from '@equinor/fusion-framework/mock';
-import { enableAppManifestMock, mockAppModules } from '@equinor/fusion-framework-app/mock';
-import { FrameworkProvider } from '@equinor/fusion-framework-react';
-import { ModuleProvider } from '@equinor/fusion-framework-react-module';
-import type { AppModule } from '@equinor/fusion-framework-module-app';
-import type { ReactElement } from 'react';
-
-const env = {
-  manifest: {
-    appKey: 'test-app',
-    displayName: 'Test App',
-    description: 'Test app',
-    type: 'standalone',
-  },
-} as const;
-
-async function renderWithHappyDom(ui: ReactElement) {
-  const framework = await mockFramework<[AppModule]>((configurator) =>
-    enableAppManifestMock(configurator, env),
-  );
-  const app = await mockAppModules(undefined, env, framework);
-  return render(ui, {
-    wrapper: ({ children }) => (
-      <FrameworkProvider value={framework}>
-        <ModuleProvider value={app}>{children}</ModuleProvider>
-      </FrameworkProvider>
-    ),
-  });
-}
-```
-
-Run the test in a Vitest project with `environment: 'happy-dom'` instead of
-`browser.enabled`. Use a separate project if the same app also has Browser Mode tests.
-
-Call the same `enable*Mock` functions from the `mockAppModules` configuration callback. These
-mocks configure Fusion modules and do not depend on the renderer. `renderHook` from
-`@testing-library/react` can use the same wrapper for hook tests.
-
-Use Browser Mode when browser behavior matters. Use `happy-dom`, `jsdom`, or no DOM for focused
-tests that only need application logic or simple rendering.
-
-## Related documentation
-
-- [Overview](overview.md)
-- [Configuration](configuration.md)
-- [Module mocks](module-mocks.md)
-- [Migrate an existing app to Fusion Vitest](migrating-an-existing-app.md)
-- [Choose a Fusion testing layer](../../../framework/docs/testing-choosing-a-layer.md)

package/src/__tests__/app-test-vite-plugin.test.ts

@@ -1,109 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { appTestVitePlugin } from '../index.js';
-
-type ResolveIdHook = (id: string) => string | null | undefined;
-type LoadHook = (id: string) => string | null | undefined | Promise<string | null | undefined>;
-type ConfigResolvedHook = (config: { root: string }) => void;
-
-describe('appTestVitePlugin', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'fusion-vitest-plugin-react-app-'));
-    await writeFile(
-      join(dir, 'package.json'),
-      JSON.stringify({ name: '@equinor/my-app', version: '1.2.3' }),
-    );
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('claims only its two virtual specifiers, leaving everything else unresolved', () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const resolveId = plugin.resolveId as ResolveIdHook;
-
-    expect(resolveId('virtual:fusion-app-test-env')).toBe('\0virtual:fusion-app-test-env');
-    expect(resolveId('virtual:fusion-app-test-configure')).toBe(
-      '\0virtual:fusion-app-test-configure',
-    );
-    expect(resolveId('some-other-module')).toBeNull();
-  });
-
-  it('serves the resolved manifest/config as the env virtual module', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-env');
-
-    expect(source).toContain('"appKey":"my-app"');
-    expect(source).toContain('export const config = {"environment":{}};');
-  });
-
-  it('serves an undefined configure export when no config file exists', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe('export const configure = undefined;');
-  });
-
-  it('resolves the app from the Vitest project root when no entrypoint is provided', async () => {
-    await mkdir(join(dir, 'src'), { recursive: true });
-    await writeFile(join(dir, 'src', 'index.ts'), 'export {};');
-    await writeFile(join(dir, 'src', 'config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin();
-    const configResolved = plugin.configResolved as ConfigResolvedHook;
-    const load = plugin.load as LoadHook;
-
-    configResolved({ root: dir });
-
-    expect(await load('\0virtual:fusion-app-test-env')).toContain('"appKey":"my-app"');
-    expect(await load('\0virtual:fusion-app-test-configure')).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'src', 'config.ts'))};`,
-    );
-  });
-
-  it('re-exports the default candidate config file as the configure virtual module', async () => {
-    await mkdir(join(dir, 'src'), { recursive: true });
-    await writeFile(join(dir, 'src', 'config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'src', 'config.ts'))};`,
-    );
-  });
-
-  it('re-exports an explicitly requested configure file', async () => {
-    await writeFile(join(dir, 'my-config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin({ entrypoint: dir, configure: 'my-config.ts' });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'my-config.ts'))};`,
-    );
-  });
-
-  it('throws when an explicitly requested configure file does not exist', () => {
-    expect(() => appTestVitePlugin({ entrypoint: dir, configure: 'missing.ts' })).toThrow();
-  });
-
-  it('returns null for module ids other than its own virtual specifiers', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    expect(await load('some-other-module')).toBeNull();
-  });
-});

package/src/__tests__/merge-env-config.test.ts

@@ -1,67 +0,0 @@
-import { AppConfig } from '@equinor/fusion-framework-module-app';
-import type { AppEnv } from '@equinor/fusion-framework-app';
-import { describe, expect, it } from 'vitest';
-
-import { mergeEnvConfig } from '../merge-env-config.js';
-
-describe('mergeEnvConfig', () => {
-  const baseEnv: AppEnv = {
-    manifest: {
-      appKey: 'test-app',
-      displayName: 'Test App',
-      description: 'A test application',
-      type: 'standalone',
-    },
-    config: new AppConfig({
-      environment: { foo: 'bar' },
-      endpoints: { api: { url: 'https://api.example.com', scopes: ['api.read'] } },
-    }),
-  };
-
-  it('adds a new endpoint without dropping existing ones', () => {
-    const merged = mergeEnvConfig(baseEnv, {
-      endpoints: { 'cpr-api': { url: 'https://cpr.example.com' } },
-    });
-
-    expect(merged.config?.endpoints).toEqual({
-      api: { url: 'https://api.example.com', scopes: ['api.read'] },
-      'cpr-api': { url: 'https://cpr.example.com', scopes: [] },
-    });
-  });
-
-  it('overrides one field of an existing endpoint, keeping the rest', () => {
-    const merged = mergeEnvConfig(baseEnv, {
-      endpoints: { api: { url: 'https://fake.example.com' } },
-    });
-
-    expect(merged.config?.endpoints.api).toEqual({
-      url: 'https://fake.example.com',
-      scopes: ['api.read'],
-    });
-  });
-
-  it('merges environment overrides over the existing environment', () => {
-    const merged = mergeEnvConfig(baseEnv, { environment: { baz: 'qux' } });
-
-    expect(merged.config?.environment).toEqual({ foo: 'bar', baz: 'qux' });
-  });
-
-  it('leaves the original env and its config untouched', () => {
-    mergeEnvConfig(baseEnv, { endpoints: { api: { url: 'https://fake.example.com' } } });
-
-    expect(baseEnv.config?.endpoints.api).toEqual({
-      url: 'https://api.example.com',
-      scopes: ['api.read'],
-    });
-  });
-
-  it('handles an env with no existing config', () => {
-    const env: AppEnv = { manifest: baseEnv.manifest };
-    const merged = mergeEnvConfig(env, { endpoints: { api: { url: 'https://api.example.com' } } });
-
-    expect(merged.config?.endpoints).toEqual({
-      api: { url: 'https://api.example.com', scopes: [] },
-    });
-    expect(merged.config?.environment).toEqual({});
-  });
-});

package/src/__tests__/resolve-app-test-env.test.ts

@@ -1,83 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { resolveAppTestEnv } from '../resolve-app-test-env.js';
-
-describe('resolveAppTestEnv', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'fusion-vitest-plugin-react-app-'));
-    await writeFile(
-      join(dir, 'package.json'),
-      JSON.stringify({ name: '@equinor/my-app', version: '1.2.3', description: 'a test app' }),
-    );
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('falls back to a package-derived manifest and an empty config with no local files', async () => {
-    const { manifest, config } = await resolveAppTestEnv({ entrypoint: dir });
-
-    expect(manifest).toMatchObject({
-      appKey: 'my-app',
-      displayName: '@equinor/my-app',
-      description: 'a test app',
-      type: 'standalone',
-    });
-    expect(config).toEqual({ environment: {} });
-  });
-
-  it('merges a local app.manifest.ts and app.config.ts, same as ffc app build', async () => {
-    await writeFile(
-      join(dir, 'app.manifest.ts'),
-      "export default { displayName: 'My Custom App' };",
-    );
-    await writeFile(
-      join(dir, 'app.config.ts'),
-      "export default { environment: {}, endpoints: { api: { url: 'https://example.com' } } };",
-    );
-
-    const { manifest, config } = await resolveAppTestEnv({ entrypoint: dir });
-
-    expect(manifest).toMatchObject({ appKey: 'my-app', displayName: 'My Custom App' });
-    expect(config).toEqual({
-      environment: {},
-      endpoints: { api: { url: 'https://example.com', scopes: [] } },
-    });
-  });
-
-  it('applies an inline manifest/config function directly, same as a loaded file default export', async () => {
-    const { manifest, config } = await resolveAppTestEnv({
-      entrypoint: dir,
-      manifest: () => ({ displayName: 'Inline App' }),
-      config: () => ({
-        environment: {},
-        endpoints: { api: { url: 'https://inline.example.com' } },
-      }),
-    });
-
-    expect(manifest).toMatchObject({ appKey: 'my-app', displayName: 'Inline App' });
-    expect(config).toEqual({
-      environment: {},
-      endpoints: { api: { url: 'https://inline.example.com', scopes: [] } },
-    });
-  });
-
-  it('propagates an error for an explicitly requested manifest file that does not exist', async () => {
-    await expect(
-      resolveAppTestEnv({ entrypoint: dir, manifest: 'does-not-exist.manifest.ts' }),
-    ).rejects.toThrow();
-  });
-
-  it('propagates an error for an explicitly requested config file that does not exist', async () => {
-    await expect(
-      resolveAppTestEnv({ entrypoint: dir, config: 'does-not-exist.config.ts' }),
-    ).rejects.toThrow();
-  });
-});

package/src/app-test.ts

@@ -1,19 +0,0 @@
-export {
-  renderAppHook,
-  type RenderAppHookOptions,
-  type RenderAppHookResult,
-} from './render-app-hook';
-export {
-  renderAppComponent,
-  type RenderAppComponentOptions,
-  type RenderAppComponentResult,
-} from './render-app-component';
-export { testApp } from './test-app';
-export { mergeEnvConfig, type MergeEnvConfigOverrides } from './merge-env-config.js';
-export type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
-
-// `test`/`render` import virtual modules only served once `appTestVitePlugin`
-// (@equinor/fusion-framework-vitest-plugin-react-app) is registered — using any export from
-// this module requires the plugin registered in your `vitest.config.ts` `plugins`.
-export { test } from './test';
-export { render } from './render';