open-metadata · shah-harshit · Aug 12, 2026 · Aug 10, 2026 · Aug 10, 2026 · Aug 12, 2026
@@ -75,15 +75,25 @@
   isAuthenticated?: boolean;
   isApplicationLoading?: boolean;
   isAuthenticating?: boolean;
+  applicationsLoaded?: boolean;
   currentUser?: Record<string, unknown>;
 }) => {
-  mockUseApplicationStore.mockImplementation(() => ({
+  const state = {
     currentUser: {},
     isAuthenticated: true,
     isApplicationLoading: false,
     isAuthenticating: false,
+    applicationsLoaded: true,
     ...overrides,
-  }));
+  };
+
+  // Honour the selector so individual fields (notably `applicationsLoaded`,
+  // which gates route registration) can be varied independently.
+  mockUseApplicationStore.mockImplementation((selector?: unknown) =>
+    typeof selector === 'function'
+      ? (selector as (s: typeof state) => unknown)(state)
+      : state
+  );
 };
 
 const ModeRoutesMock: ComponentType = () => (
@@ -122,9 +132,9 @@
    renderRouter();

    expect(
      await screen.findByTestId('default-authenticated-routes')
    ).toBeInTheDocument();
    expect(screen.queryByTestId('custom-mode-routes')).not.toBeInTheDocument();
  });

  it('wraps the rendered routes in AuthenticatedApp for an authenticated user', async () => {
@@ -162,6 +172,40 @@
     expect(screen.queryByTestId('custom-mode-routes')).not.toBeInTheDocument();
   });
 
+  it('holds a loader instead of the default routes while a non-default mode is still registering', async () => {
+    // `applications` not loaded yet — the owning plugin registers its routes in
+    // an effect gated on that, so the registry is legitimately empty here.
+    setAuthState({ isAuthenticated: true, applicationsLoaded: false });
+    writeAppMode('ai');
+
+    renderRouter();
+
+    expect(await screen.findByTestId('full-screen-loader')).toBeInTheDocument();
+    // Rendering the default routes here would mount their `path="*"`
+    // catch-all, which navigates to /404 and destroys the requested URL.
+    expect(
+      screen.queryByTestId('default-authenticated-routes')
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders the mode routes once the owning plugin registers them after applications load', async () => {
+    setAuthState({ isAuthenticated: true, applicationsLoaded: false });
+    writeAppMode('ai');
+
+    renderRouter();
+
+    expect(await screen.findByTestId('full-screen-loader')).toBeInTheDocument();
+
+    act(() => {
+      useAppRoutesRegistry.getState().registerRoutes('ai', ModeRoutesMock);
+    });
+
+    expect(await screen.findByTestId('custom-mode-routes')).toBeInTheDocument();
+    expect(
+      screen.queryByTestId('default-authenticated-routes')
+    ).not.toBeInTheDocument();
+  });
+
   it('swaps to the registered mode component when the AppMode changes mid-session', async () => {
     setAuthState({ isAuthenticated: true });
     act(() => {

@@ -15,6 +15,7 @@ import { isEmpty } from 'lodash';
 import { lazy } from 'react';
 import { Navigate, Route, Routes } from 'react-router-dom';
 import { useShallow } from 'zustand/react/shallow';
+import { DEFAULT_APP_MODE } from '../../constants/appMode.constants';
 import { APP_ROUTER_ROUTES } from '../../constants/router.constants';
 import { useApplicationStore } from '../../hooks/useApplicationStore';
 import { useAppMode } from '../../hooks/useAppMode';
@@ -82,7 +83,18 @@ const AppRouter = () => {
   const appMode = useAppMode();
   const ModeRoutes = useAppRoutesRegistry((state) => state.routes[appMode]);
 
-  useResolvedAppMode();
+  const isRegistrySettled = useResolvedAppMode();
+
+  // A non-default mode's routes are registered by the plugin that owns the
+  // mode, in an effect that waits for `applications` to load. Until then the
+  // registry looks empty, and falling through to `AuthenticatedRoutes` mounts
+  // its `path="*"` catch-all, which navigates to /404 and destroys the
+  // requested URL before the real routes ever mount — a deep link or a reload
+  // on any mode-specific route lands on Not Found, non-deterministically.
+  // `registrySettled` is what distinguishes that startup window from a mode
+  // whose plugin is genuinely uninstalled, where falling back is correct.
+  const isModeRoutesPending =
+    appMode !== DEFAULT_APP_MODE && !ModeRoutes && !isRegistrySettled;
 
   /**
    * isApplicationLoading is true when the application is loading in AuthProvider
@@ -99,9 +111,17 @@ const AppRouter = () => {
   if (isAuthenticated) {
     const AuthenticatedRoutesComponent = ModeRoutes ?? AuthenticatedRoutes;
 
+    // The loader has to sit INSIDE AuthenticatedApp: `ApplicationsProvider`
+    // lives there, and it is what flips `applicationsLoaded` and so unblocks
+    // registration. Short-circuiting above this point would deadlock — the
+    // routes could never register, so the loader would never clear.
     return (
       <AuthenticatedApp>
-        <AuthenticatedRoutesComponent />
+        {isModeRoutesPending ? (
+          <Loader fullScreen />
+        ) : (
+          <AuthenticatedRoutesComponent />
+        )}
       </AuthenticatedApp>
     );
   }

@@ -111,7 +111,7 @@
          }}
          owners={value?.assignee ? [value.assignee] : []}
          placeHolder={t('label.no-entity', {
            entity: t('label.assignee'),
          })}
          tooltipText={t('label.edit-entity', {
            entity: t('label.assignee'),
@@ -142,14 +142,14 @@
    () => (
      <div className="tw:p-4">
        {Array.from({ length: 5 }).map((_, i) => (
          <Skeleton className="tw:mb-2" height={40} key={i} width="100%" />
        ))}
      </div>
    ),
    []
  );

  const renderRow = (record: TestCaseResolutionStatus) => {
    const ref = record.testCaseReference;
    const tableFqn = getPartialNameFromTableFQN(
      ref?.fullyQualifiedName ?? '',
@@ -162,9 +162,14 @@
 
     return (
       <Table.Row id={record.id ?? ''} key={record.id}>
-        <Table.Cell className="tw:w-72 tw:min-w-56">
+        {/* The table lays out `auto`, so `wrap-break-word` would leave a long
+            test case name as one unbreakable min-content word and stretch the
+            column to fit it. `wrap-anywhere` shrinks that contribution; the
+            floor matches the declared width so auto-layout cannot then
+            collapse the column and wrap every name onto three lines. */}
+        <Table.Cell className="tw:w-72 tw:min-w-72">
           <Link
-            className="tw:m-0 tw:wrap-break-word"
+            className="tw:m-0 tw:wrap-anywhere"
             data-testid={`test-case-${ref?.name}`}
             state={{ breadcrumbData }}
             to={observabilityRouterClassBase.getTestCaseDetailPagePath(
@@ -217,7 +222,12 @@
             />
           )}
         </Table.Cell>
-        <Table.Cell>
+        {/* antd's `.ant-typography` sets `word-break: break-word`, which drops
+            the "No Assignee" placeholder's min-content contribution to a single
+            character. Owner names render nowrap+ellipsis already, so once every
+            row is unassigned nothing holds the column open and it collapses,
+            stacking the placeholder one letter per line. */}
+        <Table.Cell className="tw:whitespace-nowrap">
           {testCaseResolutionStatusDetailsRender(
             record.testCaseResolutionStatusDetails,
             record

@@ -93,10 +93,13 @@
  * the resolver falls through to compute a fresh candidate.
  *
  * Consumers should invoke this hook exactly once, high in the tree
- * (e.g. `AppRoot`). It has no return value — its effects are `writeAppMode`
- * / `clearAppMode` calls.
+ * (e.g. `AppRoot`). Its work is done through effects — `writeAppMode` /
+ * `clearAppMode` calls. It returns the `registrySettled` flag described
+ * below so the router can tell "the owning plugin has not registered its
+ * routes yet" apart from "no plugin owns this mode", which are otherwise
+ * indistinguishable from an empty registry.
  */
-export const useResolvedAppMode = (): void => {
+export const useResolvedAppMode = (): boolean => {
   const defaultPersonaId = useApplicationStore(
     (state) => state.currentUser?.defaultPersona?.id
   );
@@ -162,7 +165,7 @@
    retry: false,
  });

  useEffect(() => {
    if (!isAuthenticated || !currentUser?.name) {
      return;
    }
@@ -258,4 +261,6 @@
     registeredRoutes,
     registrySettled,
   ]);
+
+  return registrySettled;
 };
@@ -41,9 +41,19 @@
 const DataQualityProvider = ({
   children,
   createActions,
+  isActive = true,
 }: {
   children: React.ReactNode;
   createActions?: DataQualityContextInterface['createActions'];
+  /**
+   * Whether this page currently owns the URL. Filters here are derived from the
+   * query string, which is global — so a host that keeps the page mounted while
+   * routing elsewhere (AI mode caches visited routes) must pass `false`, or the
+   * backgrounded page re-derives its filters from whatever route now owns the
+   * query string and refetches with another page's params. Defaults to `true`
+   * for hosts that unmount the page on navigation.
+   */
+  isActive?: boolean;
 }) => {
   const { tab: activeTab = DataQualityPageTabs.TEST_CASES } =
     useRequiredParams<{
@@ -152,12 +162,19 @@
   };
 
   useEffect(() => {
+    // Backgrounded: hold the last loaded summary rather than refetching against
+    // a query string that now belongs to another route. Re-running on
+    // re-activation is intentional — it revalidates against the real filters.
+    if (!isActive) {
+      return;
+    }
+
     if (getPrioritizedViewPermission(testCasePermission, Operation.ViewBasic)) {
       fetchTestSummary(filterParams);
     } else {
       setIsTestCaseSummaryLoading(false);
     }
-  }, [filterKey]);
+  }, [filterKey, isActive]);
 
   return (
     <DataQualityContext.Provider value={dataQualityContextValue}>