[OP-19617] Seam the Angular-Turbo re-bootstrap

The wrapper destroys and re-bootstraps the whole Angular root on every
Turbo navigation -- the most consequential frontend/src/turbo/ installer
yet the only one left without coverage.

Threads the same (target, signal) seam and injects the plugin-context
lookup and bootstrap call so vitest can drive synthetic turbo:load
events. The RxJS skip(1) pipeline and destroy-then-bootstrap contract
are unchanged; callers stay on the defaults.

Author: myabc

frontend/src/turbo/turbo-angular-wrapper.spec.ts

@@ -0,0 +1,145 @@
+//-- copyright
+// OpenProject is an open source project management software.
+// Copyright (C) the OpenProject GmbH
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License version 3.
+//
+// OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
+// Copyright (C) 2006-2013 Jean-Philippe Lang
+// Copyright (C) 2010-2013 the ChiliProject Team
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+// See COPYRIGHT and LICENSE files for more details.
+//++
+
+import {
+  afterEach, beforeEach, describe, expect, it, vi,
+} from 'vitest';
+import type { ApplicationRef, ComponentRef } from '@angular/core';
+import type { OpenProjectPluginContext } from 'core-app/features/plugins/plugin-context';
+import { addTurboAngularWrapper } from './turbo-angular-wrapper';
+
+describe('addTurboAngularWrapper — Angular re-bootstrap on Turbo navigation', () => {
+  let controller:AbortController;
+  let target:EventTarget;
+
+  // The destroy-and-rebuild contract operates on the plugin context's appRef.
+  // We drive it with fakes so the spec never touches `window.OpenProject` or a
+  // real Angular application.
+  function makeAppRef(components:ComponentRef<unknown>[]):ApplicationRef {
+    return { components, detachView: vi.fn() } as unknown as ApplicationRef;
+  }
+
+  // The handler awaits the plugin-context promise; flush the microtask queue so
+  // assertions see the re-bootstrap that follows it.
+  async function flush():Promise<void> {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  beforeEach(() => {
+    controller = new AbortController();
+    target = new EventTarget();
+  });
+
+  afterEach(() => {
+    controller.abort();
+  });
+
+  it('re-bootstraps the Angular app on the second turbo:load', async () => {
+    const appRef = makeAppRef([]);
+    const bootstrap = vi.fn();
+    const getPluginContext = () => Promise.resolve({ appRef } as OpenProjectPluginContext);
+
+    addTurboAngularWrapper({
+      target, signal: controller.signal, getPluginContext, bootstrap,
+    });
+
+    target.dispatchEvent(new Event('turbo:load')); // initial load — already bootstrapped
+    await flush();
+    target.dispatchEvent(new Event('turbo:load')); // navigation — must re-bootstrap
+    await flush();
+
+    expect(bootstrap).toHaveBeenCalledTimes(1);
+    expect(bootstrap).toHaveBeenCalledWith(appRef);
+  });
+
+  it('tears down every existing root component before re-bootstrapping', async () => {
+    // Hold the mocks as locals so the assertions never reference an unbound
+    // method off the fake (eslint @typescript-eslint/unbound-method).
+    const firstDestroy = vi.fn();
+    const secondDestroy = vi.fn();
+    const first = { hostView: {}, destroy: firstDestroy } as unknown as ComponentRef<unknown>;
+    const second = { hostView: {}, destroy: secondDestroy } as unknown as ComponentRef<unknown>;
+    const detachView = vi.fn();
+    const appRef = { components: [first, second], detachView } as unknown as ApplicationRef;
+    const bootstrap = vi.fn();
+    const getPluginContext = () => Promise.resolve({ appRef } as OpenProjectPluginContext);
+
+    addTurboAngularWrapper({
+      target, signal: controller.signal, getPluginContext, bootstrap,
+    });
+
+    target.dispatchEvent(new Event('turbo:load')); // initial load — skipped
+    await flush();
+    target.dispatchEvent(new Event('turbo:load')); // navigation
+    await flush();
+
+    expect(detachView).toHaveBeenCalledWith(first.hostView);
+    expect(detachView).toHaveBeenCalledWith(second.hostView);
+    expect(firstDestroy).toHaveBeenCalledOnce();
+    expect(secondDestroy).toHaveBeenCalledOnce();
+    // Teardown must complete before the fresh bootstrap.
+    expect(firstDestroy).toHaveBeenCalledBefore(bootstrap);
+    expect(secondDestroy).toHaveBeenCalledBefore(bootstrap);
+  });
+
+  it('does not re-bootstrap on the initial turbo:load', async () => {
+    const appRef = makeAppRef([]);
+    const bootstrap = vi.fn();
+    const getPluginContext = vi.fn(() => Promise.resolve({ appRef } as OpenProjectPluginContext));
+
+    addTurboAngularWrapper({
+      target, signal: controller.signal, getPluginContext, bootstrap,
+    });
+
+    target.dispatchEvent(new Event('turbo:load')); // initial load only
+    await flush();
+
+    expect(getPluginContext).not.toHaveBeenCalled();
+    expect(bootstrap).not.toHaveBeenCalled();
+  });
+
+  it('stops re-bootstrapping once the signal aborts', async () => {
+    const appRef = makeAppRef([]);
+    const bootstrap = vi.fn();
+    const getPluginContext = () => Promise.resolve({ appRef } as OpenProjectPluginContext);
+
+    addTurboAngularWrapper({
+      target, signal: controller.signal, getPluginContext, bootstrap,
+    });
+
+    controller.abort();
+
+    target.dispatchEvent(new Event('turbo:load'));
+    await flush();
+    target.dispatchEvent(new Event('turbo:load'));
+    await flush();
+
+    expect(bootstrap).not.toHaveBeenCalled();
+  });
+});

frontend/src/turbo/turbo-angular-wrapper.ts

@@ -1,19 +1,41 @@
 import { skip } from 'rxjs/operators';
 import { fromEvent } from 'rxjs';
+import type { ApplicationRef } from '@angular/core';
 import { runBootstrap } from 'core-app/app.module';
 import { OpenProjectPluginContext } from 'core-app/features/plugins/plugin-context';
 
-export function addTurboAngularWrapper() {
+export interface AngularTurboBridgeOptions {
+  // The event source the bridge listens on. Defaults to the global `document`;
+  // a spec can pass its own `EventTarget` to drive synthetic `turbo:load`
+  // events in isolation.
+  target?:EventTarget;
+  // Aborts the `turbo:load` subscription so a spec (or future caller) can tear
+  // the bridge down between cases.
+  signal?:AbortSignal;
+  // Resolves the Angular plugin context carrying the `appRef`. Defaults to the
+  // real `window.OpenProject` lookup; injected so specs need no global.
+  getPluginContext?:() => Promise<OpenProjectPluginContext>;
+  // Re-bootstraps the root application onto a fresh `appBaseSelector`. Defaults
+  // to `app.module`'s `runBootstrap`.
+  bootstrap?:(appRef:ApplicationRef) => void;
+}
+
+export function addTurboAngularWrapper(options:AngularTurboBridgeOptions = {}) {
+  const {
+    target = document,
+    signal,
+    getPluginContext = () => window.OpenProject.getPluginContext(),
+    bootstrap = runBootstrap,
+  } = options;
+
   // When turbo:load fires, the angular application needs to be rebootstrapped.
   // However, we don't want this to happen on the initial page load
-  fromEvent(document, 'turbo:load')
+  const subscription = fromEvent(target, 'turbo:load')
     .pipe(
       skip(1), // Skip the first turbo:load event
     )
     .subscribe(() => {
-      void window
-        .OpenProject
-        .getPluginContext()
+      void getPluginContext()
         .then((pluginContext:OpenProjectPluginContext) => {
           const appRef = pluginContext.appRef;
 
@@ -25,7 +47,9 @@ export function addTurboAngularWrapper() {
           });
 
           // Run bootstrap again to initialize the new application
-          runBootstrap(appRef);
+          bootstrap(appRef);
         });
     });
+
+  signal?.addEventListener('abort', () => subscription.unsubscribe(), { once: true });
 }