diff --git a/frontend/packages/console-app/src/components/access-modes/__tests__/access-mode.spec.tsx b/frontend/packages/console-app/src/components/access-modes/__tests__/access-mode.spec.tsx
new file mode 100644
index 00000000000..20ef7435cac
--- /dev/null
+++ b/frontend/packages/console-app/src/components/access-modes/__tests__/access-mode.spec.tsx
@@ -0,0 +1,135 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { PersistentVolumeClaimKind } from '@console/internal/module/k8s';
+import { AccessModeSelector, getPVCAccessModes } from '../access-mode';
+
+jest.mock('@console/internal/components/storage/shared', () => ({
+  getAccessModeOptions: () => [
+    { value: 'ReadWriteOnce', title: 'Single user (RWO)' },
+    { value: 'ReadWriteMany', title: 'Shared access (RWX)' },
+    { value: 'ReadOnlyMany', title: 'Read only (ROX)' },
+    { value: 'ReadWriteOncePod', title: 'Read write once pod (RWOP)' },
+  ],
+  getAccessModeForProvisioner: jest.fn(() => ['ReadWriteOnce', 'ReadWriteMany']),
+}));
+
+describe('AccessModeSelector', () => {
+  describe('getPVCAccessModes', () => {
+    it('should return access mode titles from PVC resource', () => {
+      const mockPVC = {
+        apiVersion: 'v1',
+        kind: 'PersistentVolumeClaim',
+        metadata: { name: 'test-pvc', namespace: 'default' },
+        spec: {
+          accessModes: ['ReadWriteOnce'],
+          resources: { requests: { storage: '1Gi' } },
+          storageClassName: 'gp2',
+        },
+      } as PersistentVolumeClaimKind;
+
+      const result = getPVCAccessModes(mockPVC, 'title');
+      expect(result).toEqual(['Single user (RWO)']);
+    });
+
+    it('should return access mode values from PVC resource', () => {
+      const mockPVC = {
+        apiVersion: 'v1',
+        kind: 'PersistentVolumeClaim',
+        metadata: { name: 'test-pvc', namespace: 'default' },
+        spec: {
+          accessModes: ['ReadWriteMany'],
+          resources: { requests: { storage: '1Gi' } },
+          storageClassName: 'gp2',
+        },
+      } as PersistentVolumeClaimKind;
+
+      const result = getPVCAccessModes(mockPVC, 'value');
+      expect(result).toEqual(['ReadWriteMany']);
+    });
+
+    it('should return empty array when PVC has no access modes', () => {
+      const mockPVC = {
+        apiVersion: 'v1',
+        kind: 'PersistentVolumeClaim',
+        metadata: { name: 'test-pvc', namespace: 'default' },
+        spec: {
+          accessModes: [],
+          resources: { requests: { storage: '1Gi' } },
+          storageClassName: 'gp2',
+        },
+      } as PersistentVolumeClaimKind;
+
+      const result = getPVCAccessModes(mockPVC, 'value');
+      expect(result).toEqual([]);
+    });
+
+    it('should handle undefined PVC resource', () => {
+      const result = getPVCAccessModes(undefined, 'value');
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('AccessModeSelector', () => {
+    const defaultProps = {
+      onChange: jest.fn(),
+      loaded: true,
+      provisioner: 'kubernetes.io/aws-ebs',
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should render access mode label', () => {
+      render(<AccessModeSelector {...defaultProps} />);
+
+      expect(screen.getByText('Access mode')).toBeVisible();
+    });
+
+    it('should show loading skeleton when not loaded', () => {
+      render(<AccessModeSelector {...defaultProps} loaded={false} />);
+
+      expect(screen.getByText('Access mode')).toBeVisible();
+      expect(screen.getByRole('status', { busy: true })).toBeVisible();
+    });
+
+    it('should render select dropdown when loaded', async () => {
+      render(<AccessModeSelector {...defaultProps} />);
+
+      expect(await screen.findByRole('button')).toBeVisible();
+    });
+
+    it('should display description when provided', async () => {
+      const description = 'Select the access mode for your storage';
+      render(<AccessModeSelector {...defaultProps} description={description} />);
+
+      expect(await screen.findByText(description)).toBeVisible();
+    });
+
+    it('should open dropdown when clicked', async () => {
+      const user = userEvent.setup();
+      render(<AccessModeSelector {...defaultProps} />);
+
+      const toggle = await screen.findByRole('button');
+      await user.click(toggle);
+
+      expect(await screen.findByRole('listbox')).toBeVisible();
+    });
+
+    it('should call onChange when access mode is selected', async () => {
+      const user = userEvent.setup();
+      const onChange = jest.fn();
+      render(<AccessModeSelector {...defaultProps} onChange={onChange} />);
+
+      const toggle = await screen.findByRole('button');
+      await user.click(toggle);
+
+      expect(await screen.findByRole('listbox')).toBeVisible();
+
+      const option = screen.getByText('Shared access (RWX)');
+      await user.click(option);
+
+      expect(onChange).toHaveBeenCalledWith('ReadWriteMany');
+    });
+  });
+});
diff --git a/frontend/packages/console-app/src/components/access-modes/access-mode.tsx b/frontend/packages/console-app/src/components/access-modes/access-mode.tsx
index c979e104dee..556a1af84a2 100644
--- a/frontend/packages/console-app/src/components/access-modes/access-mode.tsx
+++ b/frontend/packages/console-app/src/components/access-modes/access-mode.tsx
@@ -146,7 +146,9 @@ export const AccessModeSelector: FC<AccessModeSelectorProps> = (props) => {
           {description}
         </p>
       )}
-      {(!loaded || !allowedAccessModes) && <div className="skeleton-text" />}
+      {(!loaded || !allowedAccessModes) && (
+        <div className="skeleton-text" role="status" aria-busy="true" />
+      )}
     </FormGroup>
   );
 };
diff --git a/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationCustomField.tsx b/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationCustomField.tsx
index 91ab8cd32a1..975a9bfaa8e 100644
--- a/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationCustomField.tsx
+++ b/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationCustomField.tsx
@@ -20,7 +20,9 @@ const ClusterConfigurationCustomField: FC<ClusterConfigurationCustomFieldProps>
   return (
     <ErrorBoundaryInline>
       <FormLayout>
-        <CustomComponent {...field.props} readonly={item.readonly} />
+        <div role="group" aria-label={item.label} data-readonly={String(item.readonly)}>
+          <CustomComponent {...field.props} readonly={item.readonly} />
+        </div>
       </FormLayout>
     </ErrorBoundaryInline>
   );
diff --git a/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationForm.tsx b/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationForm.tsx
index 18a80de41c7..52c3600f3e1 100644
--- a/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationForm.tsx
+++ b/frontend/packages/console-app/src/components/cluster-configuration/ClusterConfigurationForm.tsx
@@ -1,18 +1,29 @@
 import type { FC } from 'react';
 import { Form } from '@patternfly/react-core';
+import { useTranslation } from 'react-i18next';
 import ClusterConfigurationField from './ClusterConfigurationField';
 import type { ResolvedClusterConfigurationItem } from './types';
 
 type ClusterConfigurationFormProps = {
-  items: ResolvedClusterConfigurationItem[];
+  items?: ResolvedClusterConfigurationItem[];
 };
 
-const ClusterConfigurationForm: FC<ClusterConfigurationFormProps> = ({ items }) =>
-  items?.length > 0 ? (
-    <Form onSubmit={(event) => event.preventDefault()}>
+const ClusterConfigurationForm: FC<ClusterConfigurationFormProps> = ({ items }) => {
+  const { t } = useTranslation();
+
+  if (!items?.length) {
+    return null;
+  }
+
+  return (
+    <Form
+      aria-label={t('console-app~Cluster configuration')}
+      onSubmit={(event) => event.preventDefault()}
+    >
       {items.map((item) => (
         <ClusterConfigurationField key={item.id} item={item} />
       ))}
     </Form>
-  ) : null;
+  );
+};
 export default ClusterConfigurationForm;
diff --git a/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationCustomField.spec.tsx b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationCustomField.spec.tsx
new file mode 100644
index 00000000000..ad33c793163
--- /dev/null
+++ b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationCustomField.spec.tsx
@@ -0,0 +1,108 @@
+import type { ReactElement } from 'react';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router';
+import type { ClusterConfigurationCustomField as ClusterConfigurationCustomFieldType } from '@console/dynamic-plugin-sdk/src';
+import { ClusterConfigurationFieldType } from '@console/dynamic-plugin-sdk/src';
+import type { ResolvedCodeRefProperties } from '@console/dynamic-plugin-sdk/src/types';
+import ClusterConfigurationCustomField from '../ClusterConfigurationCustomField';
+import type { ResolvedClusterConfigurationItem } from '../types';
+
+const renderWithRouter = (ui: ReactElement) => render(<MemoryRouter>{ui}</MemoryRouter>);
+
+describe('ClusterConfigurationCustomField', () => {
+  const MockCustomComponent = () => <div>Custom Component Content</div>;
+
+  const createMockItem = (readonly: boolean): ResolvedClusterConfigurationItem => ({
+    id: 'test-item',
+    groupId: 'test-group',
+    label: 'Test Custom Field',
+    description: 'Test description',
+    field: {
+      type: ClusterConfigurationFieldType.custom,
+      component: MockCustomComponent,
+    },
+    readonly,
+  });
+
+  const createMockField = (
+    props?: ClusterConfigurationCustomFieldType['props'],
+  ): ResolvedCodeRefProperties<ClusterConfigurationCustomFieldType> => ({
+    type: ClusterConfigurationFieldType.custom,
+    component: MockCustomComponent,
+    props,
+  });
+
+  it('should render custom component', () => {
+    const item = createMockItem(false);
+    const field = createMockField();
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(screen.getByRole('group', { name: 'Test Custom Field' })).toBeVisible();
+    expect(screen.getByText('Custom Component Content')).toBeVisible();
+  });
+
+  it('should wrap content in error boundary', () => {
+    const item = createMockItem(false);
+    const field = createMockField();
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(screen.getByRole('region', { name: 'Inline error boundary' })).toBeVisible();
+  });
+
+  it('should wrap content in form layout', () => {
+    const item = createMockItem(false);
+    const field = createMockField();
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(screen.getByRole('region', { name: 'Form layout' })).toBeVisible();
+  });
+
+  it('should pass readonly prop to custom component when false', () => {
+    const item = createMockItem(false);
+    const field = createMockField();
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(screen.getByRole('group', { name: 'Test Custom Field' })).toHaveAttribute(
+      'data-readonly',
+      'false',
+    );
+  });
+
+  it('should pass readonly prop to custom component when true', () => {
+    const item = createMockItem(true);
+    const field = createMockField();
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(screen.getByRole('group', { name: 'Test Custom Field' })).toHaveAttribute(
+      'data-readonly',
+      'true',
+    );
+  });
+
+  it('should pass custom props to component', () => {
+    const CustomComponentWithProps = ({
+      customProp,
+    }: {
+      readonly: boolean;
+      customProp?: string;
+    }) => <p aria-label="Extension with custom props">{customProp}</p>;
+
+    const item = createMockItem(false);
+    const field: ResolvedCodeRefProperties<ClusterConfigurationCustomFieldType> = {
+      type: ClusterConfigurationFieldType.custom,
+      component: CustomComponentWithProps,
+      props: { customProp: 'test-value' },
+    };
+
+    renderWithRouter(<ClusterConfigurationCustomField item={item} field={field} />);
+
+    expect(
+      screen.getByRole('paragraph', { name: 'Extension with custom props' }),
+    ).toHaveTextContent('test-value');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationField.spec.tsx b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationField.spec.tsx
new file mode 100644
index 00000000000..a85f16208c8
--- /dev/null
+++ b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationField.spec.tsx
@@ -0,0 +1,96 @@
+import { render, screen } from '@testing-library/react';
+import { ClusterConfigurationFieldType } from '@console/dynamic-plugin-sdk/src';
+import ClusterConfigurationField from '../ClusterConfigurationField';
+import type { ResolvedClusterConfigurationItem } from '../types';
+
+jest.mock('../ClusterConfigurationCustomField', () => ({
+  __esModule: true,
+  default: ({ item }: { item: ResolvedClusterConfigurationItem }) => (
+    <div role="region" aria-label={item.label} data-readonly={String(item.readonly)}>
+      {item.label}
+    </div>
+  ),
+}));
+
+describe('ClusterConfigurationField', () => {
+  const createMockItem = (): ResolvedClusterConfigurationItem => ({
+    id: 'test-item',
+    groupId: 'test-group',
+    label: 'Test Field Label',
+    description: 'Test description',
+    field: {
+      type: ClusterConfigurationFieldType.custom,
+      component: jest.fn(),
+    },
+    readonly: false,
+  });
+
+  it('should render ClusterConfigurationCustomField for custom field type', () => {
+    const item = createMockItem();
+    render(<ClusterConfigurationField item={item} />);
+
+    expect(screen.getByRole('region', { name: 'Test Field Label' })).toBeVisible();
+    expect(screen.getByRole('region', { name: 'Test Field Label' })).toHaveAttribute(
+      'data-readonly',
+      'false',
+    );
+    expect(screen.getByText('Test Field Label')).toBeVisible();
+  });
+
+  it('should render null for unsupported field type', () => {
+    const item = {
+      ...createMockItem(),
+      field: {
+        type: 'unsupported' as typeof ClusterConfigurationFieldType.custom,
+        component: jest.fn(),
+      },
+    };
+
+    render(<ClusterConfigurationField item={item} />);
+    expect(screen.queryByRole('region')).not.toBeInTheDocument();
+  });
+
+  it('should pass readonly state to child component', () => {
+    const item = {
+      ...createMockItem(),
+      readonly: true,
+    };
+    render(<ClusterConfigurationField item={item} />);
+
+    expect(screen.getByRole('region', { name: 'Test Field Label' })).toHaveAttribute(
+      'data-readonly',
+      'true',
+    );
+  });
+
+  it('should render with correct item properties', () => {
+    const item: ResolvedClusterConfigurationItem = {
+      id: 'unique-id',
+      groupId: 'group-1',
+      label: 'Unique Label',
+      description: 'Unique description',
+      field: {
+        type: ClusterConfigurationFieldType.custom,
+        component: jest.fn(),
+      },
+      readonly: false,
+    };
+
+    render(<ClusterConfigurationField item={item} />);
+
+    expect(screen.getByRole('region', { name: 'Unique Label' })).toBeVisible();
+  });
+
+  it('should handle text field type by returning null', () => {
+    const item = {
+      ...createMockItem(),
+      field: {
+        type: ClusterConfigurationFieldType.text as typeof ClusterConfigurationFieldType.custom,
+        component: jest.fn(),
+      },
+    };
+
+    render(<ClusterConfigurationField item={item} />);
+    expect(screen.queryByRole('region')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationForm.spec.tsx b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationForm.spec.tsx
new file mode 100644
index 00000000000..366fc1060bb
--- /dev/null
+++ b/frontend/packages/console-app/src/components/cluster-configuration/__tests__/ClusterConfigurationForm.spec.tsx
@@ -0,0 +1,77 @@
+import { render, screen, fireEvent } from '@testing-library/react';
+import { ClusterConfigurationFieldType } from '@console/dynamic-plugin-sdk/src';
+import ClusterConfigurationForm from '../ClusterConfigurationForm';
+import type { ResolvedClusterConfigurationItem } from '../types';
+
+jest.mock('../ClusterConfigurationField', () => ({
+  __esModule: true,
+  default: ({ item }: { item: ResolvedClusterConfigurationItem }) => (
+    <section aria-label={`Configuration field ${item.id}`}>{item.label}</section>
+  ),
+}));
+
+describe('ClusterConfigurationForm', () => {
+  const createMockItem = (id: string, label: string): ResolvedClusterConfigurationItem => ({
+    id,
+    groupId: 'test-group',
+    label,
+    description: `Description for ${label}`,
+    field: {
+      type: ClusterConfigurationFieldType.custom,
+      component: jest.fn(),
+    },
+    readonly: false,
+  });
+
+  it('should render form with multiple items', () => {
+    const items = [createMockItem('item-1', 'First Item'), createMockItem('item-2', 'Second Item')];
+
+    render(<ClusterConfigurationForm items={items} />);
+
+    expect(screen.getByText('First Item')).toBeVisible();
+    expect(screen.getByText('Second Item')).toBeVisible();
+  });
+
+  it('should render null when items array is empty', () => {
+    render(<ClusterConfigurationForm items={[]} />);
+
+    expect(screen.queryByRole('form', { name: 'Cluster configuration' })).not.toBeInTheDocument();
+  });
+
+  it('should render null when items is undefined', () => {
+    render(<ClusterConfigurationForm />);
+
+    expect(screen.queryByRole('form', { name: 'Cluster configuration' })).not.toBeInTheDocument();
+  });
+
+  it('should render a form and call preventDefault on submit', () => {
+    const items = [createMockItem('item-1', 'Test Item')];
+    render(<ClusterConfigurationForm items={items} />);
+
+    const form = screen.getByRole('form', { name: 'Cluster configuration' });
+    const preventDefaultSpy = jest.spyOn(Event.prototype, 'preventDefault');
+    fireEvent.submit(form);
+    expect(preventDefaultSpy).toHaveBeenCalled();
+    preventDefaultSpy.mockRestore();
+  });
+
+  it('should render each item with unique key', () => {
+    const items = [
+      createMockItem('unique-id-1', 'Item One'),
+      createMockItem('unique-id-2', 'Item Two'),
+      createMockItem('unique-id-3', 'Item Three'),
+    ];
+
+    render(<ClusterConfigurationForm items={items} />);
+
+    expect(
+      screen.getByRole('region', { name: 'Configuration field unique-id-1' }),
+    ).toHaveTextContent('Item One');
+    expect(
+      screen.getByRole('region', { name: 'Configuration field unique-id-2' }),
+    ).toHaveTextContent('Item Two');
+    expect(
+      screen.getByRole('region', { name: 'Configuration field unique-id-3' }),
+    ).toHaveTextContent('Item Three');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginCSPStatusDetail.spec.tsx b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginCSPStatusDetail.spec.tsx
new file mode 100644
index 00000000000..25a02462bb3
--- /dev/null
+++ b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginCSPStatusDetail.spec.tsx
@@ -0,0 +1,69 @@
+import { render, screen } from '@testing-library/react';
+import * as useConsoleSelectorModule from '@console/shared/src/hooks/useConsoleSelector';
+import ConsolePluginCSPStatusDetail from '../ConsolePluginCSPStatusDetail';
+
+jest.mock('@console/shared/src/hooks/useConsoleSelector', () => ({
+  useConsoleSelector: jest.fn(),
+}));
+
+jest.mock('../ConsoleOperatorConfig', () => ({
+  ConsolePluginCSPStatus: ({ hasViolations }: { hasViolations: boolean }) => (
+    <span>{hasViolations ? 'Has violations' : 'No violations'}</span>
+  ),
+}));
+
+const mockUseConsoleSelector = useConsoleSelectorModule.useConsoleSelector as jest.Mock;
+
+describe('ConsolePluginCSPStatusDetail', () => {
+  const createMockObj = (name: string) => ({
+    metadata: { name },
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display no violations when plugin has no CSP violations', () => {
+    mockUseConsoleSelector.mockReturnValue({ 'test-plugin': false });
+
+    render(<ConsolePluginCSPStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('No violations')).toBeVisible();
+  });
+
+  it('should display has violations when plugin has CSP violations', () => {
+    mockUseConsoleSelector.mockReturnValue({ 'test-plugin': true });
+
+    render(<ConsolePluginCSPStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('Has violations')).toBeVisible();
+  });
+
+  it('should display no violations when plugin is not in violations list', () => {
+    mockUseConsoleSelector.mockReturnValue({ 'other-plugin': true });
+
+    render(<ConsolePluginCSPStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('No violations')).toBeVisible();
+  });
+
+  it('should display no violations when violations list is empty', () => {
+    mockUseConsoleSelector.mockReturnValue({});
+
+    render(<ConsolePluginCSPStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('No violations')).toBeVisible();
+  });
+
+  it('should correctly identify plugin among multiple plugins', () => {
+    mockUseConsoleSelector.mockReturnValue({
+      'plugin-a': false,
+      'target-plugin': true,
+      'plugin-b': false,
+    });
+
+    render(<ConsolePluginCSPStatusDetail obj={createMockObj('target-plugin')} />);
+
+    expect(screen.getByText('Has violations')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginDescriptionDetail.spec.tsx b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginDescriptionDetail.spec.tsx
new file mode 100644
index 00000000000..fb18a34bb4a
--- /dev/null
+++ b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginDescriptionDetail.spec.tsx
@@ -0,0 +1,86 @@
+import type { PluginInfoEntry } from '@openshift/dynamic-plugin-sdk';
+import { render, screen } from '@testing-library/react';
+import * as usePluginInfoModule from '@console/plugin-sdk/src/api/usePluginInfo';
+import ConsolePluginDescriptionDetail from '../ConsolePluginDescriptionDetail';
+
+jest.mock('@console/plugin-sdk/src/api/usePluginInfo', () => ({
+  usePluginInfo: jest.fn(),
+}));
+
+const mockUsePluginInfo = usePluginInfoModule.usePluginInfo as jest.Mock;
+
+describe('ConsolePluginDescriptionDetail', () => {
+  const createMockObj = (name: string) => ({
+    metadata: { name },
+  });
+
+  const createPluginInfo = (
+    name: string,
+    description: string | undefined,
+    status: PluginInfoEntry['status'] = 'loaded',
+  ): PluginInfoEntry =>
+    ({
+      manifest: {
+        name,
+        customProperties: description ? { console: { description } } : undefined,
+      },
+      status,
+      enabled: true,
+    } as PluginInfoEntry);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display plugin description when plugin is loaded', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'A test plugin')]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('A test plugin')).toBeVisible();
+  });
+
+  it('should display dash when plugin is not loaded', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'Description', 'pending')]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin has no description', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', undefined)]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin is not found', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('other-plugin', 'Other desc')]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin failed to load', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'Description', 'failed')]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should find correct plugin among multiple plugins', () => {
+    mockUsePluginInfo.mockReturnValue([
+      createPluginInfo('plugin-a', 'First plugin'),
+      createPluginInfo('target-plugin', 'Target description'),
+      createPluginInfo('plugin-b', 'Third plugin'),
+    ]);
+
+    render(<ConsolePluginDescriptionDetail obj={createMockObj('target-plugin')} />);
+
+    expect(screen.getByText('Target description')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginEnabledStatusDetail.spec.tsx b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginEnabledStatusDetail.spec.tsx
new file mode 100644
index 00000000000..9ae9b58aaed
--- /dev/null
+++ b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginEnabledStatusDetail.spec.tsx
@@ -0,0 +1,139 @@
+import type { PluginInfoEntry } from '@openshift/dynamic-plugin-sdk';
+import { render, screen } from '@testing-library/react';
+import * as usePluginInfoModule from '@console/plugin-sdk/src/api/usePluginInfo';
+import * as ConsoleOperatorConfigModule from '../ConsoleOperatorConfig';
+import ConsolePluginEnabledStatusDetail from '../ConsolePluginEnabledStatusDetail';
+
+jest.mock('@console/plugin-sdk/src/api/usePluginInfo', () => ({
+  usePluginInfo: jest.fn(),
+}));
+
+jest.mock('../ConsoleOperatorConfig', () => ({
+  ConsolePluginEnabledStatus: ({
+    pluginName,
+    enabled,
+  }: {
+    pluginName: string;
+    enabled: boolean;
+  }) => (
+    <span>
+      {pluginName}: {enabled ? 'Enabled' : 'Disabled'}
+    </span>
+  ),
+  developmentMode: false,
+  useConsoleOperatorConfigData: jest.fn(),
+}));
+
+const mockUsePluginInfo = usePluginInfoModule.usePluginInfo as jest.Mock;
+const mockUseConsoleOperatorConfigData = ConsoleOperatorConfigModule.useConsoleOperatorConfigData as jest.Mock;
+
+describe('ConsolePluginEnabledStatusDetail', () => {
+  const createMockObj = (name: string) => ({
+    metadata: { name },
+  });
+
+  const createPluginInfo = (
+    name: string,
+    status: PluginInfoEntry['status'] = 'loaded',
+    enabled: boolean = true,
+  ): PluginInfoEntry =>
+    ({
+      manifest: { name },
+      status,
+      enabled,
+    } as PluginInfoEntry);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display enabled status when plugin is in enabled list', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin')]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: {
+        spec: {
+          plugins: ['test-plugin'],
+        },
+      },
+      consoleOperatorConfigLoaded: true,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('test-plugin: Enabled')).toBeVisible();
+  });
+
+  it('should display disabled status when plugin is not in enabled list', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin')]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: {
+        spec: {
+          plugins: ['other-plugin'],
+        },
+      },
+      consoleOperatorConfigLoaded: true,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('test-plugin: Disabled')).toBeVisible();
+  });
+
+  it('should display dash when config is not loaded', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin')]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: null,
+      consoleOperatorConfigLoaded: false,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin name is undefined', () => {
+    mockUsePluginInfo.mockReturnValue([]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: {
+        spec: {
+          plugins: [],
+        },
+      },
+      consoleOperatorConfigLoaded: true,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={{ metadata: {} }} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should handle empty plugins list', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin')]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: {
+        spec: {
+          plugins: [],
+        },
+      },
+      consoleOperatorConfigLoaded: true,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('test-plugin: Disabled')).toBeVisible();
+  });
+
+  it('should handle undefined plugins in config', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin')]);
+    mockUseConsoleOperatorConfigData.mockReturnValue({
+      consoleOperatorConfig: {
+        spec: {},
+      },
+      consoleOperatorConfigLoaded: true,
+    });
+
+    render(<ConsolePluginEnabledStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('test-plugin: Disabled')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginStatusDetail.spec.tsx b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginStatusDetail.spec.tsx
new file mode 100644
index 00000000000..34d14a67837
--- /dev/null
+++ b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginStatusDetail.spec.tsx
@@ -0,0 +1,93 @@
+import type { PluginInfoEntry } from '@openshift/dynamic-plugin-sdk';
+import { render, screen } from '@testing-library/react';
+import * as usePluginInfoModule from '@console/plugin-sdk/src/api/usePluginInfo';
+import ConsolePluginStatusDetail from '../ConsolePluginStatusDetail';
+
+jest.mock('@console/plugin-sdk/src/api/usePluginInfo', () => ({
+  usePluginInfo: jest.fn(),
+}));
+
+jest.mock('../ConsoleOperatorConfig', () => ({
+  ConsolePluginStatus: ({ status, errorMessage }: { status: string; errorMessage?: string }) => (
+    <span>
+      {status}
+      {errorMessage && ` - ${errorMessage}`}
+    </span>
+  ),
+}));
+
+const mockUsePluginInfo = usePluginInfoModule.usePluginInfo as jest.Mock;
+
+describe('ConsolePluginStatusDetail', () => {
+  const createMockObj = (name: string) => ({
+    metadata: { name },
+  });
+
+  const createPluginInfo = (
+    name: string,
+    status: PluginInfoEntry['status'],
+    errorMessage?: string,
+  ): PluginInfoEntry =>
+    (({
+      manifest: { name },
+      status,
+      enabled: true,
+      errorMessage,
+    } as unknown) as PluginInfoEntry);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display loaded status when plugin is loaded', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'loaded')]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('loaded')).toBeVisible();
+  });
+
+  it('should display pending status when plugin is pending', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'pending')]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('pending')).toBeVisible();
+  });
+
+  it('should display failed status with error message', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', 'failed', 'Network error')]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('failed - Network error')).toBeVisible();
+  });
+
+  it('should display dash when plugin is not found', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('other-plugin', 'loaded')]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin list is empty', () => {
+    mockUsePluginInfo.mockReturnValue([]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should find correct plugin among multiple plugins', () => {
+    mockUsePluginInfo.mockReturnValue([
+      createPluginInfo('plugin-a', 'loaded'),
+      createPluginInfo('target-plugin', 'pending'),
+      createPluginInfo('plugin-b', 'loaded'),
+    ]);
+
+    render(<ConsolePluginStatusDetail obj={createMockObj('target-plugin')} />);
+
+    expect(screen.getByText('pending')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginVersionDetail.spec.tsx b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginVersionDetail.spec.tsx
new file mode 100644
index 00000000000..bc675b13b37
--- /dev/null
+++ b/frontend/packages/console-app/src/components/console-operator/__tests__/ConsolePluginVersionDetail.spec.tsx
@@ -0,0 +1,81 @@
+import type { PluginInfoEntry } from '@openshift/dynamic-plugin-sdk';
+import { render, screen } from '@testing-library/react';
+import * as usePluginInfoModule from '@console/plugin-sdk/src/api/usePluginInfo';
+import ConsolePluginVersionDetail from '../ConsolePluginVersionDetail';
+
+jest.mock('@console/plugin-sdk/src/api/usePluginInfo', () => ({
+  usePluginInfo: jest.fn(),
+}));
+
+const mockUsePluginInfo = usePluginInfoModule.usePluginInfo as jest.Mock;
+
+describe('ConsolePluginVersionDetail', () => {
+  const createMockObj = (name: string) => ({
+    metadata: { name },
+  });
+
+  const createPluginInfo = (
+    name: string,
+    version: string,
+    status: PluginInfoEntry['status'] = 'loaded',
+  ): PluginInfoEntry =>
+    ({
+      manifest: { name, version },
+      status,
+      enabled: true,
+    } as PluginInfoEntry);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display plugin version when plugin is found', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('test-plugin', '1.2.3')]);
+
+    render(<ConsolePluginVersionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('1.2.3')).toBeVisible();
+  });
+
+  it('should display dash when plugin is not found', () => {
+    mockUsePluginInfo.mockReturnValue([createPluginInfo('other-plugin', '1.0.0')]);
+
+    render(<ConsolePluginVersionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin has no version', () => {
+    mockUsePluginInfo.mockReturnValue([
+      {
+        manifest: { name: 'test-plugin' },
+        status: 'loaded',
+        enabled: true,
+      } as PluginInfoEntry,
+    ]);
+
+    render(<ConsolePluginVersionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when plugin list is empty', () => {
+    mockUsePluginInfo.mockReturnValue([]);
+
+    render(<ConsolePluginVersionDetail obj={createMockObj('test-plugin')} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should find correct plugin among multiple plugins', () => {
+    mockUsePluginInfo.mockReturnValue([
+      createPluginInfo('plugin-a', '1.0.0'),
+      createPluginInfo('target-plugin', '2.5.0'),
+      createPluginInfo('plugin-b', '3.0.0'),
+    ]);
+
+    render(<ConsolePluginVersionDetail obj={createMockObj('target-plugin')} />);
+
+    expect(screen.getByText('2.5.0')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/dashboards-page/__tests__/ClusterUpdateActivity.spec.tsx b/frontend/packages/console-app/src/components/dashboards-page/__tests__/ClusterUpdateActivity.spec.tsx
new file mode 100644
index 00000000000..5fef5d386d0
--- /dev/null
+++ b/frontend/packages/console-app/src/components/dashboards-page/__tests__/ClusterUpdateActivity.spec.tsx
@@ -0,0 +1,78 @@
+import { render, screen } from '@testing-library/react';
+import type { ClusterVersionKind } from '@console/internal/module/k8s';
+import ClusterUpdateActivity from '../ClusterUpdateActivity';
+
+jest.mock('@console/shared/src/components/dashboard/activity-card/ActivityItem', () => ({
+  __esModule: true,
+  default: ({ children }: { children: React.ReactNode }) => (
+    <article aria-label="Cluster update activity">{children}</article>
+  ),
+}));
+
+describe('ClusterUpdateActivity', () => {
+  const createMockClusterVersion = (version: string): ClusterVersionKind =>
+    ({
+      apiVersion: 'config.openshift.io/v1',
+      kind: 'ClusterVersion',
+      metadata: {
+        name: 'version',
+      },
+      status: {
+        history: [
+          {
+            version,
+            state: 'Partial',
+            startedTime: '2024-01-15T10:00:00Z',
+          },
+        ],
+      },
+    } as ClusterVersionKind);
+
+  it('should render update message with version number', () => {
+    const resource = createMockClusterVersion('4.15.0');
+    render(<ClusterUpdateActivity resource={resource} />);
+
+    expect(screen.getByText('Updating cluster to 4.15.0')).toBeVisible();
+  });
+
+  it('should render activity item wrapper', () => {
+    const resource = createMockClusterVersion('4.14.5');
+    render(<ClusterUpdateActivity resource={resource} />);
+
+    expect(screen.getByRole('article', { name: 'Cluster update activity' })).toBeVisible();
+  });
+
+  it('should display different version numbers correctly', () => {
+    const resource = createMockClusterVersion('4.16.0-rc.1');
+    render(<ClusterUpdateActivity resource={resource} />);
+
+    expect(screen.getByText('Updating cluster to 4.16.0-rc.1')).toBeVisible();
+  });
+
+  it('should handle empty history gracefully', () => {
+    const resource: ClusterVersionKind = {
+      apiVersion: 'config.openshift.io/v1',
+      kind: 'ClusterVersion',
+      metadata: { name: 'version' },
+      status: {
+        history: [],
+      },
+    } as ClusterVersionKind;
+
+    render(<ClusterUpdateActivity resource={resource} />);
+
+    expect(screen.getByRole('article', { name: 'Cluster update activity' })).toBeVisible();
+  });
+
+  it('should update the message when the resource version changes', () => {
+    const resource1 = createMockClusterVersion('4.15.0');
+    const { rerender } = render(<ClusterUpdateActivity resource={resource1} />);
+
+    expect(screen.getByText('Updating cluster to 4.15.0')).toBeVisible();
+
+    const resource2 = createMockClusterVersion('4.15.1');
+    rerender(<ClusterUpdateActivity resource={resource2} />);
+
+    expect(screen.getByText('Updating cluster to 4.15.1')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/dashboards-page/__tests__/ControlPlaneStatus.spec.tsx b/frontend/packages/console-app/src/components/dashboards-page/__tests__/ControlPlaneStatus.spec.tsx
new file mode 100644
index 00000000000..45460d7d326
--- /dev/null
+++ b/frontend/packages/console-app/src/components/dashboards-page/__tests__/ControlPlaneStatus.spec.tsx
@@ -0,0 +1,145 @@
+import { render, screen } from '@testing-library/react';
+import type { PrometheusResponse } from '@console/internal/components/graphs';
+import ControlPlanePopup from '../ControlPlaneStatus';
+
+jest.mock('@console/shared/src/components/dashboard/status-card/states', () => ({
+  HealthState: {
+    OK: 'OK',
+    WARNING: 'WARNING',
+    ERROR: 'ERROR',
+    LOADING: 'LOADING',
+    UNKNOWN: 'UNKNOWN',
+    NOT_AVAILABLE: 'NOT_AVAILABLE',
+  },
+  healthStateMapping: {
+    OK: { icon: <span role="img" aria-label="OK health" />, priority: 0 },
+    WARNING: { icon: <span role="img" aria-label="Warning health" />, priority: 1 },
+    ERROR: { icon: <span role="img" aria-label="Error health" />, priority: 2 },
+    LOADING: { icon: <span role="img" aria-label="Loading health" />, priority: -1 },
+    UNKNOWN: { icon: <span role="img" aria-label="Unknown health" />, priority: 0 },
+    NOT_AVAILABLE: { icon: <span role="img" aria-label="Not available health" />, priority: 0 },
+  },
+  healthStateMessage: jest.fn((state: string) => `${state} message`),
+}));
+
+jest.mock('@console/shared/src/components/dashboard/status-card/StatusPopup', () => ({
+  __esModule: true,
+  default: ({
+    children,
+    value,
+    icon,
+  }: {
+    children: React.ReactNode;
+    value: string;
+    icon: React.ReactNode;
+  }) => (
+    <tr>
+      <th scope="row">{children}</th>
+      <td>
+        {icon}
+        <span role="status">{value}</span>
+      </td>
+    </tr>
+  ),
+  StatusPopupSection: ({
+    children,
+    firstColumn,
+    secondColumn,
+  }: {
+    children: React.ReactNode;
+    firstColumn: string;
+    secondColumn: string;
+  }) => (
+    <table>
+      <caption className="pf-v6-u-screen-reader">Control plane component health</caption>
+      <thead>
+        <tr>
+          <th scope="col">{firstColumn}</th>
+          <th scope="col">{secondColumn}</th>
+        </tr>
+      </thead>
+      <tbody>{children}</tbody>
+    </table>
+  ),
+}));
+
+jest.mock('../status', () => ({
+  getControlPlaneComponentHealth: jest.fn((response, error) => {
+    if (error) {
+      return { state: 'NOT_AVAILABLE', message: 'Not available' };
+    }
+    if (!response) {
+      return { state: 'LOADING' };
+    }
+    return { state: 'OK', message: '99%' };
+  }),
+}));
+
+describe('ControlPlanePopup', () => {
+  const createMockResponse = (value: string): { response: PrometheusResponse; error: null } => ({
+    response: {
+      status: 'success',
+      data: {
+        resultType: 'vector',
+        result: [{ metric: {}, value: [Date.now() / 1000, value] }],
+      },
+    },
+    error: null,
+  });
+
+  const createMockResponses = (count: number) =>
+    Array(count)
+      .fill(null)
+      .map(() => createMockResponse('0.99'));
+
+  const defaultProps = {
+    responses: createMockResponses(4),
+    hide: jest.fn(),
+  };
+
+  it('should render control plane description', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(
+      screen.getByText(
+        'Components of the control plane are responsible for maintaining and reconciling the state of the cluster.',
+      ),
+    ).toBeVisible();
+  });
+
+  it('should render components column header', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByRole('columnheader', { name: 'Components' })).toBeVisible();
+  });
+
+  it('should render response rate column header', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByRole('columnheader', { name: 'Response rate' })).toBeVisible();
+  });
+
+  it('should render API Servers status', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByText('API Servers')).toBeVisible();
+  });
+
+  it('should render Controller Managers status', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByText('Controller Managers')).toBeVisible();
+  });
+
+  it('should render Schedulers status', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByText('Schedulers')).toBeVisible();
+  });
+
+  it('should render API Request Success Rate status', () => {
+    render(<ControlPlanePopup {...defaultProps} />);
+
+    expect(screen.getByText('API Request Success Rate')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/dashboards-page/__tests__/OperatorStatus.spec.tsx b/frontend/packages/console-app/src/components/dashboards-page/__tests__/OperatorStatus.spec.tsx
new file mode 100644
index 00000000000..c4e4f1886ed
--- /dev/null
+++ b/frontend/packages/console-app/src/components/dashboards-page/__tests__/OperatorStatus.spec.tsx
@@ -0,0 +1,132 @@
+import { render, screen, within } from '@testing-library/react';
+import { MemoryRouter } from 'react-router';
+import type { ClusterOperator } from '@console/internal/module/k8s';
+import ClusterOperatorStatusRow from '../OperatorStatus';
+
+jest.mock('@console/internal/components/utils/resource-link', () => ({
+  ResourceLink: ({ name, kind }: { name: string; kind: string }) => (
+    <a href={`#/test-resource/${kind}/${name}`}>{name}</a>
+  ),
+}));
+
+jest.mock('@console/internal/models', () => ({
+  ClusterOperatorModel: {
+    kind: 'ClusterOperator',
+    apiVersion: 'config.openshift.io/v1',
+    apiGroup: 'config.openshift.io',
+    plural: 'clusteroperators',
+  },
+}));
+
+jest.mock('@console/internal/module/k8s', () => ({
+  referenceForModel: jest.fn(() => 'config.openshift.io~v1~ClusterOperator'),
+}));
+
+jest.mock('@console/shared/src/components/dashboard/status-card/StatusPopup', () => ({
+  __esModule: true,
+  default: ({
+    children,
+    value,
+    icon,
+  }: {
+    children: React.ReactNode;
+    value: string;
+    icon: React.ReactNode;
+  }) => (
+    <div role="region" aria-label="Operator status">
+      {icon}
+      <div role="status">{value}</div>
+      <div>{children}</div>
+    </div>
+  ),
+}));
+
+describe('ClusterOperatorStatusRow', () => {
+  const createMockOperatorStatus = (name: string, statusTitle: string) => ({
+    status: {
+      title: statusTitle,
+      icon: (
+        <span role="img" aria-label={`${statusTitle} status icon`}>
+          {statusTitle} Icon
+        </span>
+      ),
+      priority: 0,
+      health: 'OK' as const,
+    },
+    operators: [
+      {
+        apiVersion: 'config.openshift.io/v1',
+        kind: 'ClusterOperator',
+        metadata: {
+          name,
+        },
+      } as ClusterOperator,
+    ],
+  });
+
+  it('should render operator status value', () => {
+    const operatorStatus = createMockOperatorStatus('authentication', 'Available');
+
+    render(
+      <MemoryRouter>
+        <ClusterOperatorStatusRow operatorStatus={operatorStatus} />
+      </MemoryRouter>,
+    );
+
+    const region = screen.getByRole('region', { name: 'Operator status' });
+    expect(within(region).getByRole('status')).toHaveTextContent('Available');
+  });
+
+  it('should render operator name as resource link', () => {
+    const operatorStatus = createMockOperatorStatus('console', 'Degraded');
+
+    render(
+      <MemoryRouter>
+        <ClusterOperatorStatusRow operatorStatus={operatorStatus} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'console' })).toBeVisible();
+  });
+
+  it('should render status icon', () => {
+    const operatorStatus = createMockOperatorStatus('network', 'Progressing');
+
+    render(
+      <MemoryRouter>
+        <ClusterOperatorStatusRow operatorStatus={operatorStatus} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('img', { name: 'Progressing status icon' })).toHaveTextContent(
+      'Progressing Icon',
+    );
+  });
+
+  it('should render status popup wrapper', () => {
+    const operatorStatus = createMockOperatorStatus('dns', 'Available');
+
+    render(
+      <MemoryRouter>
+        <ClusterOperatorStatusRow operatorStatus={operatorStatus} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('region', { name: 'Operator status' })).toBeVisible();
+  });
+
+  it('should use correct kind reference for resource link', () => {
+    const operatorStatus = createMockOperatorStatus('ingress', 'Available');
+
+    render(
+      <MemoryRouter>
+        <ClusterOperatorStatusRow operatorStatus={operatorStatus} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'ingress' })).toHaveAttribute(
+      'href',
+      '#/test-resource/config.openshift.io~v1~ClusterOperator/ingress',
+    );
+  });
+});
diff --git a/frontend/packages/console-app/src/components/dashboards-page/dynamic-plugins-health-resource/__tests__/NotLoadedDynamicPlugins.spec.tsx b/frontend/packages/console-app/src/components/dashboards-page/dynamic-plugins-health-resource/__tests__/NotLoadedDynamicPlugins.spec.tsx
new file mode 100644
index 00000000000..2002908562f
--- /dev/null
+++ b/frontend/packages/console-app/src/components/dashboards-page/dynamic-plugins-health-resource/__tests__/NotLoadedDynamicPlugins.spec.tsx
@@ -0,0 +1,117 @@
+import type { FailedPluginInfoEntry, PendingPluginInfoEntry } from '@openshift/dynamic-plugin-sdk';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router';
+import NotLoadedDynamicPlugins from '../NotLoadedDynamicPlugins';
+
+jest.mock('@console/internal/components/utils/resource-link', () => ({
+  ResourceLink: ({ name, kind }: { name: string; kind: string }) => (
+    <a href={`#/test-resource/${kind}/${name}`}>{name}</a>
+  ),
+}));
+
+jest.mock('@console/internal/models', () => ({
+  ConsolePluginModel: {
+    kind: 'ConsolePlugin',
+    apiVersion: 'console.openshift.io/v1',
+    apiGroup: 'console.openshift.io',
+    plural: 'consoleplugins',
+  },
+}));
+
+jest.mock('@console/internal/module/k8s', () => ({
+  referenceForModel: jest.fn(() => 'console.openshift.io~v1~ConsolePlugin'),
+}));
+
+jest.mock('@console/shared/src/components/dashboard/status-card/StatusPopup', () => ({
+  StatusPopupSection: ({
+    children,
+    firstColumn,
+  }: {
+    children: React.ReactNode;
+    firstColumn: string;
+  }) => (
+    <section aria-labelledby="dynamic-plugins-section-heading">
+      <h2 id="dynamic-plugins-section-heading">{firstColumn}</h2>
+      {children}
+    </section>
+  ),
+}));
+
+describe('NotLoadedDynamicPlugins', () => {
+  const createMockPlugin = (name: string): FailedPluginInfoEntry | PendingPluginInfoEntry =>
+    ({
+      status: 'failed',
+      manifest: {
+        name,
+        version: '1.0.0',
+      },
+    } as FailedPluginInfoEntry);
+
+  it('should render section label', () => {
+    const plugins = [createMockPlugin('test-plugin')];
+
+    render(
+      <MemoryRouter>
+        <NotLoadedDynamicPlugins plugins={plugins} label="Failed plugins" />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('heading', { name: 'Failed plugins', level: 2 })).toBeVisible();
+  });
+
+  it('should render single plugin as resource link', () => {
+    const plugins = [createMockPlugin('my-plugin')];
+
+    render(
+      <MemoryRouter>
+        <NotLoadedDynamicPlugins plugins={plugins} label="Failed plugins" />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'my-plugin' })).toBeVisible();
+  });
+
+  it('should render multiple plugins as list', () => {
+    const plugins = [
+      createMockPlugin('plugin-one'),
+      createMockPlugin('plugin-two'),
+      createMockPlugin('plugin-three'),
+    ];
+
+    render(
+      <MemoryRouter>
+        <NotLoadedDynamicPlugins plugins={plugins} label="Pending plugins" />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'plugin-one' })).toBeVisible();
+    expect(screen.getByRole('link', { name: 'plugin-two' })).toBeVisible();
+    expect(screen.getByRole('link', { name: 'plugin-three' })).toBeVisible();
+  });
+
+  it('should render with correct kind reference', () => {
+    const plugins = [createMockPlugin('test-plugin')];
+
+    render(
+      <MemoryRouter>
+        <NotLoadedDynamicPlugins plugins={plugins} label="Failed plugins" />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'test-plugin' })).toHaveAttribute(
+      'href',
+      '#/test-resource/console.openshift.io~v1~ConsolePlugin/test-plugin',
+    );
+  });
+
+  it('should render empty list when no plugins provided', () => {
+    render(
+      <MemoryRouter>
+        <NotLoadedDynamicPlugins plugins={[]} label="Failed plugins" />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('heading', { name: 'Failed plugins', level: 2 })).toBeVisible();
+    expect(screen.queryByRole('link')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/favorite/FavoriteNavItem.tsx b/frontend/packages/console-app/src/components/favorite/FavoriteNavItem.tsx
index 133683b7d75..cf952ee7ad8 100644
--- a/frontend/packages/console-app/src/components/favorite/FavoriteNavItem.tsx
+++ b/frontend/packages/console-app/src/components/favorite/FavoriteNavItem.tsx
@@ -13,7 +13,13 @@ export const FavoriteNavItem: FC<FavoriteNavItemProps> = ({
 }) => {
   return (
     <NavItem className={className} isActive={isActive}>
-      <NavLink {...navLinkProps} {...dataAttributes} to={to} className="pf-v6-u-py-0 pf-v6-u-pr-0">
+      <NavLink
+        {...navLinkProps}
+        {...dataAttributes}
+        to={to}
+        className="pf-v6-u-py-0 pf-v6-u-pr-0"
+        aria-current={isActive ? 'page' : undefined}
+      >
         {children}
       </NavLink>
     </NavItem>
diff --git a/frontend/packages/console-app/src/components/favorite/__tests__/FavoriteNavItem.spec.tsx b/frontend/packages/console-app/src/components/favorite/__tests__/FavoriteNavItem.spec.tsx
new file mode 100644
index 00000000000..076a10521f4
--- /dev/null
+++ b/frontend/packages/console-app/src/components/favorite/__tests__/FavoriteNavItem.spec.tsx
@@ -0,0 +1,81 @@
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { FavoriteNavItem } from '../FavoriteNavItem';
+
+describe('FavoriteNavItem', () => {
+  it('should render children as link text', () => {
+    renderWithProviders(
+      <FavoriteNavItem to="/test" isActive={false} className="test-class">
+        Test Link
+      </FavoriteNavItem>,
+    );
+
+    expect(screen.getByRole('link', { name: 'Test Link' })).toBeVisible();
+  });
+
+  it('should render link with correct href', () => {
+    renderWithProviders(
+      <FavoriteNavItem to="/dashboard/pods" isActive={false} className="test-class">
+        Pods
+      </FavoriteNavItem>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Pods' });
+    expect(link).toHaveAttribute('href', '/dashboard/pods');
+  });
+
+  it('sets aria-current for active item when location matches the link', () => {
+    render(
+      <MemoryRouter initialEntries={['/test']}>
+        <FavoriteNavItem to="/test" isActive className="test-class">
+          Active Link
+        </FavoriteNavItem>
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('link', { name: 'Active Link' })).toBeVisible();
+    expect(screen.getByRole('link', { name: 'Active Link' })).toHaveAttribute(
+      'aria-current',
+      'page',
+    );
+  });
+
+  it('should not mark inactive link as current page', () => {
+    renderWithProviders(
+      <FavoriteNavItem to="/test" isActive={false} className="test-class">
+        Inactive Link
+      </FavoriteNavItem>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Inactive Link' });
+    expect(link).not.toHaveAttribute('aria-current', 'page');
+  });
+
+  it('should render link within list item when custom className is provided', () => {
+    renderWithProviders(
+      <FavoriteNavItem to="/test" isActive={false} className="custom-favorite-class">
+        Custom Class Link
+      </FavoriteNavItem>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Custom Class Link' });
+    expect(screen.getByRole('listitem')).toContainElement(link);
+  });
+
+  it('should pass data attributes to link', () => {
+    renderWithProviders(
+      <FavoriteNavItem
+        to="/test"
+        isActive={false}
+        className="test-class"
+        dataAttributes={{ 'data-test': 'favorite-link' }}
+      >
+        Link with Data Attr
+      </FavoriteNavItem>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Link with Data Attr' });
+    expect(link).toHaveAttribute('data-test', 'favorite-link');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/NavItemHref.tsx b/frontend/packages/console-app/src/components/nav/NavItemHref.tsx
index c7676b575b4..b37c31d9530 100644
--- a/frontend/packages/console-app/src/components/nav/NavItemHref.tsx
+++ b/frontend/packages/console-app/src/components/nav/NavItemHref.tsx
@@ -39,7 +39,12 @@ export const NavItemHref: FC<NavItemHrefProps> = ({
   }, [activeNamespace, href, namespaced, prefixNamespaced]);
   return (
     <NavItem isActive={isActive}>
-      <NavLink {...navLinkProps} {...dataAttributes} to={to()}>
+      <NavLink
+        {...navLinkProps}
+        {...dataAttributes}
+        to={to()}
+        aria-current={isActive ? 'page' : undefined}
+      >
         {children}
       </NavLink>
     </NavItem>
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/NavHeader.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/NavHeader.spec.tsx
new file mode 100644
index 00000000000..e8354ff7836
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/NavHeader.spec.tsx
@@ -0,0 +1,130 @@
+import { screen, waitForElementToBeRemoved } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useActivePerspective } from '@console/dynamic-plugin-sdk';
+import { usePerspectives } from '@console/shared/src/hooks/usePerspectives';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import NavHeader from '../NavHeader';
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  useActivePerspective: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/hooks/usePerspectives', () => ({
+  usePerspectives: jest.fn(),
+}));
+
+jest.mock('@console/internal/components/utils/async', () => ({
+  AsyncComponent: () => null,
+}));
+
+const mockSetActivePerspective = jest.fn();
+
+const createMockPerspective = (id: string, name: string) => ({
+  uid: `perspective-${id}`,
+  properties: {
+    id,
+    name,
+    icon: jest.fn(() => Promise.resolve({ default: () => null })),
+  },
+});
+
+describe('NavHeader', () => {
+  const mockOnPerspectiveSelected = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useActivePerspective as jest.Mock).mockReturnValue(['admin', mockSetActivePerspective]);
+  });
+
+  describe('when multiple perspectives are available', () => {
+    const multiplePerspectives = [
+      createMockPerspective('admin', 'Administrator'),
+      createMockPerspective('dev', 'Developer'),
+    ];
+
+    beforeEach(() => {
+      (usePerspectives as jest.Mock).mockReturnValue(multiplePerspectives);
+    });
+
+    it('should render perspective switcher dropdown with toggle button', () => {
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      const toggle = screen.getByRole('button', { expanded: false });
+      expect(toggle).toBeVisible();
+      expect(screen.getByRole('heading', { name: 'Administrator' })).toBeVisible();
+    });
+
+    it('should open dropdown menu when toggle is clicked', async () => {
+      const user = userEvent.setup();
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      const toggle = screen.getByRole('button', { expanded: false });
+      await user.click(toggle);
+
+      expect(await screen.findByRole('button', { expanded: true })).toBeVisible();
+    });
+
+    it('should display all perspective options in dropdown menu', async () => {
+      const user = userEvent.setup();
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      await user.click(screen.getByRole('button'));
+
+      expect(await screen.findByRole('listbox')).toBeVisible();
+      expect(screen.getAllByRole('option')).toHaveLength(2);
+    });
+
+    it('should switch perspective when an option is selected', async () => {
+      const user = userEvent.setup();
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      await user.click(screen.getByRole('button'));
+
+      expect(await screen.findByRole('button', { expanded: true })).toBeVisible();
+
+      const devOption = screen.getByRole('heading', { name: 'Developer' });
+      await user.click(devOption);
+
+      expect(mockSetActivePerspective).toHaveBeenCalledWith('dev');
+      expect(mockOnPerspectiveSelected).toHaveBeenCalled();
+    });
+
+    it('should close dropdown after selecting a perspective', async () => {
+      const user = userEvent.setup();
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      await user.click(screen.getByRole('button'));
+
+      const listbox = await screen.findByRole('listbox');
+      expect(listbox).toBeVisible();
+
+      const options = screen.getAllByRole('option');
+      await user.click(options[0]);
+
+      await waitForElementToBeRemoved(listbox);
+    });
+  });
+
+  describe('when only one perspective is available', () => {
+    it('should render static Core platform text without dropdown', () => {
+      (usePerspectives as jest.Mock).mockReturnValue([
+        createMockPerspective('admin', 'Administrator'),
+      ]);
+
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      expect(screen.getByRole('heading', { name: /Core platform/i })).toBeVisible();
+      expect(screen.queryByRole('button')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('when no perspectives are available', () => {
+    it('should render fallback when perspectives array is empty', () => {
+      (usePerspectives as jest.Mock).mockReturnValue([]);
+
+      renderWithProviders(<NavHeader onPerspectiveSelected={mockOnPerspectiveSelected} />);
+
+      expect(screen.getByRole('heading')).toBeVisible();
+    });
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/NavItemHref.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/NavItemHref.spec.tsx
new file mode 100644
index 00000000000..1cd5cb61741
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/NavItemHref.spec.tsx
@@ -0,0 +1,115 @@
+import { screen } from '@testing-library/react';
+import { useActiveNamespace } from '@console/shared/src/hooks/useActiveNamespace';
+import { useLocation } from '@console/shared/src/hooks/useLocation';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { NavItemHref } from '../NavItemHref';
+
+jest.mock('@console/shared/src/hooks/useActiveNamespace', () => ({
+  useActiveNamespace: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/hooks/useLocation', () => ({
+  useLocation: jest.fn(),
+}));
+
+describe('NavItemHref', () => {
+  const mockSetNamespace = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useActiveNamespace as jest.Mock).mockReturnValue(['default', mockSetNamespace]);
+    (useLocation as jest.Mock).mockReturnValue('/other/path');
+  });
+
+  it('should render children as link text', () => {
+    renderWithProviders(<NavItemHref href="/dashboard">Dashboard</NavItemHref>);
+
+    expect(screen.getByRole('link', { name: 'Dashboard' })).toBeVisible();
+  });
+
+  it('should use href directly when not namespaced', () => {
+    renderWithProviders(<NavItemHref href="/cluster-settings">Cluster Settings</NavItemHref>);
+
+    const link = screen.getByRole('link', { name: 'Cluster Settings' });
+    expect(link).toHaveAttribute('href', '/cluster-settings');
+  });
+
+  it('should format namespaced route when namespaced prop is true', () => {
+    renderWithProviders(
+      <NavItemHref href="/pods" namespaced>
+        Pods
+      </NavItemHref>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Pods' });
+    // formatNamespacedRouteForHref formats as /{href}/ns/{namespace}
+    expect(link).toHaveAttribute('href', '/pods/ns/default');
+  });
+
+  it('should format prefixNamespaced route correctly', () => {
+    renderWithProviders(
+      <NavItemHref href="/k8s/ns/test/configmaps" prefixNamespaced>
+        ConfigMaps
+      </NavItemHref>,
+    );
+
+    const link = screen.getByRole('link', { name: 'ConfigMaps' });
+    expect(link).toHaveAttribute('href', '/k8s/ns/default/configmaps');
+  });
+
+  it('should mark nav item as active when location matches href', () => {
+    (useLocation as jest.Mock).mockReturnValue('/dashboard');
+
+    renderWithProviders(<NavItemHref href="/dashboard">Dashboard</NavItemHref>);
+
+    expect(screen.getByRole('link', { name: 'Dashboard', current: 'page' })).toBeVisible();
+  });
+
+  it('should not be active when location does not match href', () => {
+    (useLocation as jest.Mock).mockReturnValue('/other/path');
+
+    renderWithProviders(<NavItemHref href="/dashboard">Dashboard</NavItemHref>);
+
+    expect(screen.getByRole('link', { name: 'Dashboard' })).toBeVisible();
+    expect(
+      screen.queryByRole('link', { name: 'Dashboard', current: 'page' }),
+    ).not.toBeInTheDocument();
+  });
+
+  it('should pass data attributes to link', () => {
+    renderWithProviders(
+      <NavItemHref href="/settings" dataAttributes={{ 'data-test': 'settings-link' }}>
+        Settings
+      </NavItemHref>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Settings' });
+    expect(link).toHaveAttribute('data-test', 'settings-link');
+  });
+
+  it('should be active when location matches startsWith pattern', () => {
+    (useLocation as jest.Mock).mockReturnValue('/monitoring/alerts');
+
+    renderWithProviders(
+      <NavItemHref href="/monitoring" startsWith={['monitoring/alerts', 'monitoring/dashboards']}>
+        Monitoring
+      </NavItemHref>,
+    );
+
+    expect(screen.getByRole('link', { name: 'Monitoring', current: 'page' })).toBeVisible();
+  });
+
+  it('should handle all-namespaces scope in active namespace', () => {
+    (useActiveNamespace as jest.Mock).mockReturnValue(['#ALL_NS#', mockSetNamespace]);
+
+    renderWithProviders(
+      <NavItemHref href="/pods" namespaced>
+        Pods
+      </NavItemHref>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Pods' });
+    // formatNamespacedRouteForHref formats as /{href}/all-namespaces for #ALL_NS#
+    expect(link).toHaveAttribute('href', '/pods/all-namespaces');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/NavLink.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/NavLink.spec.tsx
new file mode 100644
index 00000000000..9c91b445b9f
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/NavLink.spec.tsx
@@ -0,0 +1,54 @@
+import { createRef } from 'react';
+import { screen } from '@testing-library/react';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { NavLink } from '../NavLink';
+
+describe('NavLink', () => {
+  it('should render children correctly', () => {
+    renderWithProviders(
+      <NavLink to="/test">
+        <span>Test Link Content</span>
+      </NavLink>,
+    );
+
+    expect(screen.getByText('Test Link Content')).toBeVisible();
+  });
+
+  it('should render as a link with correct href', () => {
+    renderWithProviders(<NavLink to="/dashboard">Dashboard</NavLink>);
+
+    const link = screen.getByRole('link', { name: 'Dashboard' });
+    expect(link).toHaveAttribute('href', '/dashboard');
+  });
+
+  it('should have data-test attribute for testing', () => {
+    renderWithProviders(<NavLink to="/test">Test</NavLink>);
+
+    const link = screen.getByRole('link', { name: 'Test' });
+    expect(link).toHaveAttribute('data-test', 'nav');
+  });
+
+  it('should pass additional link props to the underlying Link component', () => {
+    renderWithProviders(
+      <NavLink to="/settings" className="custom-nav-link" aria-label="Settings page">
+        Settings
+      </NavLink>,
+    );
+
+    const link = screen.getByRole('link', { name: 'Settings page' });
+    expect(link).toHaveAttribute('href', '/settings');
+  });
+
+  it('should forward dragRef to the Link element', () => {
+    const dragRef = createRef<HTMLAnchorElement>();
+
+    renderWithProviders(
+      <NavLink to="/draggable" dragRef={dragRef}>
+        Draggable Item
+      </NavLink>,
+    );
+
+    expect(dragRef.current).toBeInstanceOf(HTMLAnchorElement);
+    expect(dragRef.current).toHaveAttribute('href', '/draggable');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/NavSection.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/NavSection.spec.tsx
new file mode 100644
index 00000000000..65f3453695b
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/NavSection.spec.tsx
@@ -0,0 +1,194 @@
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { HrefNavItem, ResourceNavItem, Separator } from '@console/dynamic-plugin-sdk';
+import {
+  isHrefNavItem,
+  isResourceNavItem,
+  isSeparator,
+  isResourceNSNavItem,
+} from '@console/dynamic-plugin-sdk';
+import type { LoadedExtension } from '@console/dynamic-plugin-sdk/src/types';
+import { useK8sModels } from '@console/shared/src/hooks/useK8sModels';
+import { useLocation } from '@console/shared/src/hooks/useLocation';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { NavSection } from '../NavSection';
+import { useNavExtensionsForSection } from '../useNavExtensionsForSection';
+
+jest.mock('@console/shared/src/hooks/useK8sModels', () => ({
+  useK8sModels: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/hooks/useLocation', () => ({
+  useLocation: jest.fn(),
+}));
+
+jest.mock('../useNavExtensionsForSection', () => ({
+  useNavExtensionsForSection: jest.fn(),
+}));
+
+jest.mock('../NavItemHref', () => ({
+  NavItemHref: ({ children }: { children: React.ReactNode }) => (
+    <li data-test="nav-item-href">{children}</li>
+  ),
+}));
+
+jest.mock('../NavItemResource', () => ({
+  NavItemResource: ({ children }: { children: React.ReactNode }) => (
+    <li data-test="nav-item-resource">{children}</li>
+  ),
+}));
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  ...jest.requireActual('@console/dynamic-plugin-sdk'),
+  isHrefNavItem: jest.fn(),
+  isResourceNavItem: jest.fn(),
+  isSeparator: jest.fn(),
+  isResourceNSNavItem: jest.fn(),
+}));
+
+const createHrefExtension = (id: string, name: string): LoadedExtension<HrefNavItem> =>
+  ({
+    type: 'console.navigation/href',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name,
+      href: `/${id}`,
+      section: 'workloads',
+    },
+  } as LoadedExtension<HrefNavItem>);
+
+const createResourceExtension = (id: string, name: string): LoadedExtension<ResourceNavItem> =>
+  ({
+    type: 'console.navigation/resource-ns',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name,
+      model: { group: '', version: 'v1', kind: 'Pod' },
+      section: 'workloads',
+    },
+  } as LoadedExtension<ResourceNavItem>);
+
+const createSeparatorExtension = (id: string): LoadedExtension<Separator> =>
+  ({
+    type: 'console.navigation/separator',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      section: 'workloads',
+    },
+  } as LoadedExtension<Separator>);
+
+describe('NavSection', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useK8sModels as jest.Mock).mockReturnValue([{}]);
+    (useLocation as jest.Mock).mockReturnValue('/other/path');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(false);
+    ((isResourceNavItem as unknown) as jest.Mock).mockReturnValue(false);
+    ((isSeparator as unknown) as jest.Mock).mockReturnValue(false);
+    ((isResourceNSNavItem as unknown) as jest.Mock).mockReturnValue(false);
+  });
+
+  it('should return null when section has no children', () => {
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([]);
+
+    renderWithProviders(<NavSection id="empty-section" name="Empty Section" />);
+
+    expect(screen.queryByRole('button', { name: /Empty Section/i })).not.toBeInTheDocument();
+    expect(screen.queryByRole('group', { name: 'Navigation' })).not.toBeInTheDocument();
+  });
+
+  it('should render expandable section with name', () => {
+    const hrefExtension = createHrefExtension('dashboard', 'Dashboard');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([hrefExtension]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<NavSection id="workloads" name="Workloads" />);
+
+    expect(screen.getByRole('button', { name: /Workloads/i })).toBeVisible();
+  });
+
+  it('should render NavGroup without title when name is empty', () => {
+    const hrefExtension = createHrefExtension('home', 'Home');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([hrefExtension]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<NavSection id="home" name="" />);
+
+    // Should render children but not as expandable
+    expect(screen.queryByRole('button')).not.toBeInTheDocument();
+    expect(screen.getByText('Home')).toBeVisible();
+  });
+
+  it('should render href nav items', async () => {
+    const user = userEvent.setup();
+    const hrefExtension = createHrefExtension('dashboard', 'Dashboard');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([hrefExtension]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockImplementation((ext) => ext === hrefExtension);
+
+    renderWithProviders(<NavSection id="workloads" name="Workloads" />);
+
+    await user.click(screen.getByRole('button', { name: /Workloads/i }));
+
+    expect(await screen.findByText('Dashboard')).toBeVisible();
+  });
+
+  it('should render resource nav items', async () => {
+    const user = userEvent.setup();
+    const resourceExtension = createResourceExtension('pods', 'Pods');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([resourceExtension]);
+    ((isResourceNavItem as unknown) as jest.Mock).mockImplementation(
+      (ext) => ext === resourceExtension,
+    );
+
+    renderWithProviders(<NavSection id="workloads" name="Workloads" />);
+
+    await user.click(screen.getByRole('button', { name: /Workloads/i }));
+
+    expect(await screen.findByText('Pods')).toBeVisible();
+  });
+
+  it('should render separators between items', () => {
+    const separatorExtension = createSeparatorExtension('separator-1');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([separatorExtension]);
+    ((isSeparator as unknown) as jest.Mock).mockImplementation((ext) => ext === separatorExtension);
+
+    renderWithProviders(<NavSection id="workloads" name="Workloads" />);
+
+    expect(screen.getByRole('presentation', { hidden: true })).toBeInTheDocument();
+  });
+
+  it('should expand section when toggle is clicked', async () => {
+    const user = userEvent.setup();
+    const hrefExtension = createHrefExtension('dashboard', 'Dashboard');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([hrefExtension]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<NavSection id="workloads" name="Workloads" />);
+
+    const toggle = screen.getByRole('button', { name: /Workloads/i });
+    await user.click(toggle);
+
+    expect(await screen.findByRole('button', { name: /Workloads/i, expanded: true })).toBe(toggle);
+  });
+
+  it('should pass data attributes to section', () => {
+    const hrefExtension = createHrefExtension('dashboard', 'Dashboard');
+    (useNavExtensionsForSection as jest.Mock).mockReturnValue([hrefExtension]);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(
+      <NavSection
+        id="workloads"
+        name="Workloads"
+        dataAttributes={{ 'data-test': 'workloads-section' }}
+      />,
+    );
+
+    const toggle = screen.getByRole('button', { name: /Workloads/i });
+    expect(toggle).toHaveAttribute('data-test', 'workloads-section');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/Navigation.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/Navigation.spec.tsx
new file mode 100644
index 00000000000..4b35915a066
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/Navigation.spec.tsx
@@ -0,0 +1,108 @@
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { Navigation } from '../index';
+
+jest.mock('../NavHeader', () => ({
+  __esModule: true,
+  default: ({ onPerspectiveSelected }: { onPerspectiveSelected: () => void }) => (
+    <div role="region" aria-label="Nav header">
+      <button onClick={onPerspectiveSelected} type="button">
+        Select Perspective
+      </button>
+    </div>
+  ),
+}));
+
+jest.mock('../PerspectiveNav', () => ({
+  __esModule: true,
+  default: () => (
+    <div role="region" aria-label="Perspective navigation">
+      Perspective Nav Content
+    </div>
+  ),
+}));
+
+describe('Navigation', () => {
+  const mockOnNavSelect = jest.fn();
+  const mockOnPerspectiveSelected = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should render navigation sidebar when isNavOpen is true', () => {
+    renderWithProviders(
+      <Navigation
+        isNavOpen
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    expect(screen.getByRole('navigation')).toBeVisible();
+  });
+
+  it('should render NavHeader component', () => {
+    renderWithProviders(
+      <Navigation
+        isNavOpen
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    expect(screen.getByRole('region', { name: 'Nav header' })).toBeVisible();
+  });
+
+  it('should render PerspectiveNav component', () => {
+    renderWithProviders(
+      <Navigation
+        isNavOpen
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    expect(screen.getByRole('region', { name: 'Perspective navigation' })).toBeVisible();
+  });
+
+  it('should pass onPerspectiveSelected callback to NavHeader', async () => {
+    const user = userEvent.setup();
+    renderWithProviders(
+      <Navigation
+        isNavOpen
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    await user.click(screen.getByRole('button', { name: 'Select Perspective' }));
+
+    expect(mockOnPerspectiveSelected).toHaveBeenCalled();
+  });
+
+  it('should have accessible aria-label on Nav', () => {
+    renderWithProviders(
+      <Navigation
+        isNavOpen
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    expect(screen.getByRole('navigation')).toHaveAttribute('aria-label', 'Nav');
+  });
+
+  it('should hide sidebar when isNavOpen is false', () => {
+    renderWithProviders(
+      <Navigation
+        isNavOpen={false}
+        onNavSelect={mockOnNavSelect}
+        onPerspectiveSelected={mockOnPerspectiveSelected}
+      />,
+    );
+
+    expect(screen.getByTestId('navigation-page-sidebar')).toHaveAttribute('aria-hidden', 'true');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/PinnedResource.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/PinnedResource.spec.tsx
new file mode 100644
index 00000000000..32b71b4f947
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/PinnedResource.spec.tsx
@@ -0,0 +1,123 @@
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useK8sModel } from '@console/shared/src/hooks/useK8sModel';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import PinnedResource from '../PinnedResource';
+import useConfirmNavUnpinModal from '../useConfirmNavUnpinModal';
+
+// Note: useConfirmNavUnpinModal is imported for the type check in assertions
+
+jest.mock('@console/shared/src/hooks/useK8sModel', () => ({
+  useK8sModel: jest.fn(),
+}));
+
+const mockConfirmUnpinModal = jest.fn();
+jest.mock('../useConfirmNavUnpinModal', () => ({
+  __esModule: true,
+  default: jest.fn(() => mockConfirmUnpinModal),
+}));
+
+jest.mock('../NavItemResource', () => ({
+  NavItemResource: ({ children }: { children: React.ReactNode }) => children,
+}));
+
+const mockK8sModel = {
+  apiVersion: 'v1',
+  apiGroup: '',
+  namespaced: true,
+  kind: 'ConfigMap',
+  label: 'ConfigMap',
+  labelPlural: 'ConfigMaps',
+  labelPluralKey: 'public~ConfigMaps',
+  plural: 'configmaps',
+  abbr: 'CM',
+};
+
+describe('PinnedResource', () => {
+  const mockOnChange = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return null when model is not found', () => {
+    (useK8sModel as jest.Mock).mockReturnValue([undefined, false]);
+
+    renderWithProviders(
+      <PinnedResource
+        resourceRef="unknown~v1~Unknown"
+        navResources={['unknown~v1~Unknown']}
+        onChange={mockOnChange}
+        idx={0}
+      />,
+    );
+
+    expect(screen.queryByTestId('draggable-pinned-resource-item')).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Unpin' })).not.toBeInTheDocument();
+  });
+
+  it('should render pinned resource with label when model exists', () => {
+    (useK8sModel as jest.Mock).mockReturnValue([mockK8sModel, false]);
+
+    renderWithProviders(
+      <PinnedResource
+        resourceRef="core~v1~ConfigMap"
+        navResources={['core~v1~ConfigMap']}
+        onChange={mockOnChange}
+        idx={0}
+      />,
+    );
+
+    expect(screen.getByText(/ConfigMaps/)).toBeInTheDocument();
+  });
+
+  it('should render unpin button with accessible label', () => {
+    (useK8sModel as jest.Mock).mockReturnValue([mockK8sModel, false]);
+
+    renderWithProviders(
+      <PinnedResource
+        resourceRef="core~v1~ConfigMap"
+        navResources={['core~v1~ConfigMap']}
+        onChange={mockOnChange}
+        idx={0}
+      />,
+    );
+
+    expect(screen.getByRole('button', { name: 'Unpin' })).toBeVisible();
+  });
+
+  it('should call confirm unpin modal when remove button is clicked', async () => {
+    const user = userEvent.setup();
+    (useK8sModel as jest.Mock).mockReturnValue([mockK8sModel, false]);
+
+    renderWithProviders(
+      <PinnedResource
+        resourceRef="core~v1~ConfigMap"
+        navResources={['core~v1~ConfigMap']}
+        onChange={mockOnChange}
+        idx={0}
+      />,
+    );
+
+    const unpinButton = screen.getByRole('button', { name: 'Unpin' });
+    await user.click(unpinButton);
+
+    expect(mockConfirmUnpinModal).toHaveBeenCalledWith('core~v1~ConfigMap');
+  });
+
+  it('should pass onChange and navResources to useConfirmNavUnpinModal', () => {
+    (useK8sModel as jest.Mock).mockReturnValue([mockK8sModel, false]);
+    const navResources = ['core~v1~ConfigMap', 'build.openshift.io~v1~BuildConfig'];
+
+    renderWithProviders(
+      <PinnedResource
+        resourceRef="core~v1~ConfigMap"
+        navResources={navResources}
+        onChange={mockOnChange}
+        idx={0}
+      />,
+    );
+
+    expect(useConfirmNavUnpinModal).toHaveBeenCalledWith(navResources, mockOnChange);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/PluginNavItem.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/PluginNavItem.spec.tsx
new file mode 100644
index 00000000000..f26a523c197
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/PluginNavItem.spec.tsx
@@ -0,0 +1,195 @@
+import { screen } from '@testing-library/react';
+import type {
+  NavSection as NavSectionType,
+  HrefNavItem,
+  ResourceNavItem,
+  Separator,
+} from '@console/dynamic-plugin-sdk';
+import {
+  isNavSection,
+  isSeparator,
+  isHrefNavItem,
+  isResourceNSNavItem,
+  isResourceNavItem,
+  useActivePerspective,
+} from '@console/dynamic-plugin-sdk';
+import type { LoadedExtension } from '@console/dynamic-plugin-sdk/src/types';
+import { renderWithProviders } from '@console/shared/src/test-utils/unit-test-utils';
+import { PluginNavItem } from '../PluginNavItem';
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  ...jest.requireActual('@console/dynamic-plugin-sdk'),
+  isNavSection: jest.fn(),
+  isSeparator: jest.fn(),
+  isHrefNavItem: jest.fn(),
+  isResourceNSNavItem: jest.fn(),
+  isResourceNavItem: jest.fn(),
+  useActivePerspective: jest.fn(),
+}));
+
+jest.mock('../NavSection', () => ({
+  NavSection: ({ id, name }: { id: string; name: string }) => (
+    <div data-test="nav-section" data-id={id}>
+      {name}
+    </div>
+  ),
+}));
+
+jest.mock('../NavItemHref', () => ({
+  NavItemHref: ({ children }: { children: React.ReactNode }) => (
+    <li data-test="nav-item-href">{children}</li>
+  ),
+}));
+
+jest.mock('../NavItemResource', () => ({
+  NavItemResource: ({ children }: { children: React.ReactNode }) => (
+    <li data-test="nav-item-resource">{children}</li>
+  ),
+}));
+
+jest.mock('../../favorite/FavoriteNavItems', () => ({
+  FavoriteNavItems: () => <div data-test="favorite-nav-items">Favorites</div>,
+}));
+
+const createNavSectionExtension = (id: string, name: string): LoadedExtension<NavSectionType> =>
+  ({
+    type: 'console.navigation/section',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name,
+    },
+  } as LoadedExtension<NavSectionType>);
+
+const createHrefExtension = (id: string, name: string): LoadedExtension<HrefNavItem> =>
+  ({
+    type: 'console.navigation/href',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name,
+      href: `/${id}`,
+    },
+  } as LoadedExtension<HrefNavItem>);
+
+const createResourceExtension = (id: string, name: string): LoadedExtension<ResourceNavItem> =>
+  ({
+    type: 'console.navigation/resource-ns',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name,
+      model: { group: '', version: 'v1', kind: 'Pod' },
+    },
+  } as LoadedExtension<ResourceNavItem>);
+
+const createSeparatorExtension = (id: string): LoadedExtension<Separator> =>
+  ({
+    type: 'console.navigation/separator',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+    },
+  } as LoadedExtension<Separator>);
+
+describe('PluginNavItem', () => {
+  const mockSetPerspective = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useActivePerspective as jest.Mock).mockReturnValue(['admin', mockSetPerspective]);
+    ((isNavSection as unknown) as jest.Mock).mockReturnValue(false);
+    ((isSeparator as unknown) as jest.Mock).mockReturnValue(false);
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(false);
+    ((isResourceNavItem as unknown) as jest.Mock).mockReturnValue(false);
+    ((isResourceNSNavItem as unknown) as jest.Mock).mockReturnValue(false);
+  });
+
+  it('should render NavSection for section extension', () => {
+    const sectionExtension = createNavSectionExtension('workloads', 'Workloads');
+    ((isNavSection as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={sectionExtension} />);
+
+    expect(screen.getByTestId('nav-section')).toBeVisible();
+    expect(screen.getByText('Workloads')).toBeVisible();
+  });
+
+  it('should render FavoriteNavItems for home section in admin perspective', () => {
+    const homeSection = createNavSectionExtension('home', 'Home');
+    ((isNavSection as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={homeSection} />);
+
+    expect(screen.getByTestId('favorite-nav-items')).toBeVisible();
+  });
+
+  it('should not render FavoriteNavItems for home section in non-admin perspective', () => {
+    (useActivePerspective as jest.Mock).mockReturnValue(['dev', mockSetPerspective]);
+    const homeSection = createNavSectionExtension('home', 'Home');
+    ((isNavSection as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={homeSection} />);
+
+    expect(screen.queryByTestId('favorite-nav-items')).not.toBeInTheDocument();
+  });
+
+  it('should render separator with presentation role', () => {
+    const separatorExtension = createSeparatorExtension('sep-1');
+    ((isSeparator as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={separatorExtension} />);
+
+    expect(screen.getByRole('presentation')).toBeInTheDocument();
+  });
+
+  it('should render NavItemHref for href extension', () => {
+    const hrefExtension = createHrefExtension('dashboard', 'Dashboard');
+    ((isHrefNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={hrefExtension} />);
+
+    expect(screen.getByTestId('nav-item-href')).toBeVisible();
+    expect(screen.getByText('Dashboard')).toBeVisible();
+  });
+
+  it('should render NavItemResource for resource extension', () => {
+    const resourceExtension = createResourceExtension('pods', 'Pods');
+    ((isResourceNavItem as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={resourceExtension} />);
+
+    expect(screen.getByTestId('nav-item-resource')).toBeVisible();
+    expect(screen.getByText('Pods')).toBeVisible();
+  });
+
+  it('should return null and warn for unrecognized extension', () => {
+    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+    const unknownExtension = ({
+      type: 'console.navigation/unknown',
+      uid: 'uid-unknown',
+      properties: { id: 'unknown' },
+    } as unknown) as LoadedExtension<NavSectionType>;
+
+    renderWithProviders(<PluginNavItem extension={unknownExtension} />);
+
+    expect(screen.queryByTestId('nav-section')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('favorite-nav-items')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('nav-item-href')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('nav-item-resource')).not.toBeInTheDocument();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Invalid or unrecognized navigation extension:',
+      unknownExtension,
+    );
+    consoleSpy.mockRestore();
+  });
+
+  it('should not render FavoriteNavItems for non-home sections', () => {
+    const workloadsSection = createNavSectionExtension('workloads', 'Workloads');
+    ((isNavSection as unknown) as jest.Mock).mockReturnValue(true);
+
+    renderWithProviders(<PluginNavItem extension={workloadsSection} />);
+
+    expect(screen.queryByTestId('favorite-nav-items')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/useConfirmNavUnpinModal.spec.tsx b/frontend/packages/console-app/src/components/nav/__tests__/useConfirmNavUnpinModal.spec.tsx
new file mode 100644
index 00000000000..653ef626688
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/useConfirmNavUnpinModal.spec.tsx
@@ -0,0 +1,113 @@
+import { isValidElement } from 'react';
+import type { ReactElement } from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { modelFor } from '@console/internal/module/k8s';
+import { useWarningModal } from '@console/shared/src/hooks/useWarningModal';
+import useConfirmNavUnpinModal from '../useConfirmNavUnpinModal';
+
+jest.mock('@console/internal/module/k8s', () => ({
+  modelFor: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/hooks/useWarningModal', () => ({
+  useWarningModal: jest.fn(),
+}));
+
+describe('useConfirmNavUnpinModal', () => {
+  const mockConfirmModalLauncher = jest.fn();
+  const mockUpdatePinsFn = jest.fn();
+  const pinnedResources = ['core~v1~ConfigMap', 'apps~v1~Deployment'];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useWarningModal as jest.Mock).mockReturnValue(mockConfirmModalLauncher);
+    (modelFor as jest.Mock).mockReturnValue({ labelPlural: 'ConfigMaps' });
+  });
+
+  it('should initialize useWarningModal with correct options', () => {
+    renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    expect(useWarningModal).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: expect.any(String),
+        cancelButtonLabel: expect.any(String),
+        confirmButtonLabel: expect.any(String),
+        ouiaId: 'NavigationUnpinConfirmation',
+      }),
+    );
+  });
+
+  it('should return a function to launch the confirm modal', () => {
+    const { result } = renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    expect(typeof result.current).toBe('function');
+  });
+
+  it('should launch modal with correct message when called', () => {
+    const { result } = renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    act(() => {
+      result.current('core~v1~ConfigMap');
+    });
+
+    expect(mockConfirmModalLauncher).toHaveBeenCalledTimes(1);
+    const { children, onConfirm } = mockConfirmModalLauncher.mock.calls[0][0];
+    expect(typeof onConfirm).toBe('function');
+    expect(isValidElement(children)).toBe(true);
+    expect((children as ReactElement).type).toBe('span');
+  });
+
+  it('should remove resource from pinned list when confirmed', async () => {
+    const { result } = renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    act(() => {
+      result.current('core~v1~ConfigMap');
+    });
+
+    // Get the onConfirm callback that was passed to the modal
+    const { onConfirm } = mockConfirmModalLauncher.mock.calls[0][0];
+
+    await act(async () => {
+      await onConfirm();
+    });
+
+    expect(mockUpdatePinsFn).toHaveBeenCalledWith(['apps~v1~Deployment']);
+  });
+
+  it('should use model labelPlural for confirmation message', () => {
+    (modelFor as jest.Mock).mockReturnValue({ labelPlural: 'Deployments' });
+
+    const { result } = renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    act(() => {
+      result.current('apps~v1~Deployment');
+    });
+
+    expect(modelFor).toHaveBeenCalledWith('apps~v1~Deployment');
+    expect(mockConfirmModalLauncher).toHaveBeenCalled();
+  });
+
+  it('should handle undefined model gracefully', () => {
+    (modelFor as jest.Mock).mockReturnValue(undefined);
+
+    const { result } = renderHook(() => useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn));
+
+    act(() => {
+      result.current('unknown~v1~Resource');
+    });
+
+    expect(mockConfirmModalLauncher).toHaveBeenCalled();
+  });
+
+  it('should maintain stable callback reference', () => {
+    const { result, rerender } = renderHook(() =>
+      useConfirmNavUnpinModal(pinnedResources, mockUpdatePinsFn),
+    );
+
+    const firstCallback = result.current;
+    rerender();
+    const secondCallback = result.current;
+
+    expect(firstCallback).toBe(secondCallback);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionForPerspective.spec.ts b/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionForPerspective.spec.ts
new file mode 100644
index 00000000000..eb2b272d1a6
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionForPerspective.spec.ts
@@ -0,0 +1,133 @@
+import { renderHook } from '@testing-library/react';
+import type { NavExtension } from '@console/dynamic-plugin-sdk/src/lib-core';
+import type { LoadedExtension } from '@console/dynamic-plugin-sdk/src/types';
+import { useExtensions } from '@console/plugin-sdk/src/api/useExtensions';
+import { usePerspectives } from '@console/shared/src/hooks/usePerspectives';
+import { useNavExtensionsForPerspective } from '../useNavExtensionForPerspective';
+
+jest.mock('@console/plugin-sdk/src/api/useExtensions', () => ({
+  useExtensions: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/hooks/usePerspectives', () => ({
+  usePerspectives: jest.fn(),
+}));
+
+const createNavExtension = (id: string, perspective?: string): LoadedExtension<NavExtension> =>
+  ({
+    type: 'console.navigation/href',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name: `Nav ${id}`,
+      href: `/${id}`,
+      perspective,
+    },
+  } as LoadedExtension<NavExtension>);
+
+const createPerspective = (id: string, isDefault = false) => ({
+  uid: `perspective-${id}`,
+  properties: {
+    id,
+    name: id.charAt(0).toUpperCase() + id.slice(1),
+    default: isDefault,
+  },
+});
+
+describe('useNavExtensionsForPerspective', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (usePerspectives as jest.Mock).mockReturnValue([]);
+    (useExtensions as jest.Mock).mockReturnValue([]);
+  });
+
+  it('should return empty array when no extensions exist', () => {
+    (useExtensions as jest.Mock).mockReturnValue([]);
+
+    const { result } = renderHook(() => useNavExtensionsForPerspective('admin'));
+
+    expect(result.current).toEqual([]);
+  });
+
+  it('should return extensions matching the perspective', () => {
+    const adminExtension = createNavExtension('admin-nav', 'admin');
+    const devExtension = createNavExtension('dev-nav', 'dev');
+    (useExtensions as jest.Mock).mockReturnValue([adminExtension, devExtension]);
+
+    const { result } = renderHook(() => useNavExtensionsForPerspective('admin'));
+
+    expect(result.current).toHaveLength(1);
+    expect(result.current[0].properties.id).toBe('admin-nav');
+  });
+
+  it('should include extensions without perspective for default perspective', () => {
+    const adminPerspective = createPerspective('admin', true);
+    const noPerspectiveExtension = createNavExtension('global-nav');
+    const adminExtension = createNavExtension('admin-nav', 'admin');
+
+    (usePerspectives as jest.Mock).mockReturnValue([adminPerspective]);
+    (useExtensions as jest.Mock).mockReturnValue([noPerspectiveExtension, adminExtension]);
+
+    const { result } = renderHook(() => useNavExtensionsForPerspective('admin'));
+
+    expect(result.current).toHaveLength(2);
+  });
+
+  it('should not include extensions without perspective for non-default perspective', () => {
+    const adminPerspective = createPerspective('admin', true);
+    const devPerspective = createPerspective('dev', false);
+    const noPerspectiveExtension = createNavExtension('global-nav');
+    const devExtension = createNavExtension('dev-nav', 'dev');
+
+    (usePerspectives as jest.Mock).mockReturnValue([adminPerspective, devPerspective]);
+    (useExtensions as jest.Mock).mockReturnValue([noPerspectiveExtension, devExtension]);
+
+    const { result } = renderHook(() => useNavExtensionsForPerspective('dev'));
+
+    expect(result.current).toHaveLength(1);
+    expect(result.current[0].properties.id).toBe('dev-nav');
+  });
+
+  it('should handle undefined perspectives array', () => {
+    (usePerspectives as jest.Mock).mockReturnValue(undefined);
+    const adminExtension = createNavExtension('admin-nav', 'admin');
+    (useExtensions as jest.Mock).mockReturnValue([adminExtension]);
+
+    const { result } = renderHook(() => useNavExtensionsForPerspective('admin'));
+
+    expect(result.current).toHaveLength(1);
+  });
+
+  it('should return new array reference when extensions change', () => {
+    const ext1 = createNavExtension('nav-1', 'admin');
+    const ext2 = createNavExtension('nav-2', 'admin');
+
+    (useExtensions as jest.Mock).mockReturnValue([ext1]);
+
+    const { result, rerender } = renderHook(() => useNavExtensionsForPerspective('admin'));
+    const firstResult = result.current;
+
+    (useExtensions as jest.Mock).mockReturnValue([ext1, ext2]);
+    rerender();
+
+    expect(result.current).not.toBe(firstResult);
+    expect(result.current).toHaveLength(2);
+  });
+
+  it('should handle multiple perspectives with same extension', () => {
+    const adminPerspective = createPerspective('admin', false);
+    const devPerspective = createPerspective('dev', true);
+    const sharedExtension = createNavExtension('shared-nav');
+
+    (usePerspectives as jest.Mock).mockReturnValue([adminPerspective, devPerspective]);
+    (useExtensions as jest.Mock).mockReturnValue([sharedExtension]);
+
+    // For default perspective (dev), should include extensions without perspective
+    const { result: devResult } = renderHook(() => useNavExtensionsForPerspective('dev'));
+    expect(devResult.current).toHaveLength(1);
+
+    // For non-default perspective (admin), should not include
+    const { result: adminResult } = renderHook(() => useNavExtensionsForPerspective('admin'));
+    expect(adminResult.current).toHaveLength(0);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionsForSection.spec.ts b/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionsForSection.spec.ts
new file mode 100644
index 00000000000..aa4077f35dd
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/useNavExtensionsForSection.spec.ts
@@ -0,0 +1,121 @@
+import { renderHook } from '@testing-library/react';
+import { useActivePerspective } from '@console/dynamic-plugin-sdk/src/lib-core';
+import type { NavExtension } from '@console/dynamic-plugin-sdk/src/lib-core';
+import type { LoadedExtension } from '@console/dynamic-plugin-sdk/src/types';
+import { useNavExtensionsForPerspective } from '../useNavExtensionForPerspective';
+import { useNavExtensionsForSection } from '../useNavExtensionsForSection';
+
+jest.mock('@console/dynamic-plugin-sdk/src/lib-core', () => ({
+  useActivePerspective: jest.fn(),
+}));
+
+jest.mock('../useNavExtensionForPerspective', () => ({
+  useNavExtensionsForPerspective: jest.fn(),
+}));
+
+const createNavExtension = (
+  id: string,
+  section?: string,
+  insertAfter?: string,
+): LoadedExtension<NavExtension> =>
+  ({
+    type: 'console.navigation/href',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name: `Nav ${id}`,
+      href: `/${id}`,
+      section,
+      insertAfter,
+    },
+  } as LoadedExtension<NavExtension>);
+
+describe('useNavExtensionsForSection', () => {
+  const mockSetPerspective = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useActivePerspective as jest.Mock).mockReturnValue(['admin', mockSetPerspective]);
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([]);
+  });
+
+  it('should return empty array when no extensions for section', () => {
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([]);
+
+    const { result } = renderHook(() => useNavExtensionsForSection('workloads'));
+
+    expect(result.current).toEqual([]);
+  });
+
+  it('should return extensions matching the section', () => {
+    const workloadsExt = createNavExtension('pods', 'workloads');
+    const networkingExt = createNavExtension('services', 'networking');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([workloadsExt, networkingExt]);
+
+    const { result } = renderHook(() => useNavExtensionsForSection('workloads'));
+
+    expect(result.current).toHaveLength(1);
+    expect(result.current[0].properties.id).toBe('pods');
+  });
+
+  it('should sort extensions using getSortedNavExtensions', () => {
+    // ext2 has insertAfter: 'deployments', so it should come after ext1
+    const ext1 = createNavExtension('deployments', 'workloads');
+    const ext2 = createNavExtension('pods', 'workloads', 'deployments');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([ext2, ext1]);
+
+    const { result } = renderHook(() => useNavExtensionsForSection('workloads'));
+
+    // Verify sorting happened - ext1 (deployments) should come before ext2 (pods)
+    expect(result.current).toHaveLength(2);
+    expect(result.current[0].properties.id).toBe('deployments');
+    expect(result.current[1].properties.id).toBe('pods');
+  });
+
+  it('should use active perspective from hook', () => {
+    (useActivePerspective as jest.Mock).mockReturnValue(['dev', mockSetPerspective]);
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([]);
+
+    renderHook(() => useNavExtensionsForSection('workloads'));
+
+    expect(useNavExtensionsForPerspective).toHaveBeenCalledWith('dev');
+  });
+
+  it('should filter extensions by exact section match', () => {
+    const workloadsExt = createNavExtension('pods', 'workloads');
+    const workloads2Ext = createNavExtension('deployments', 'workloads-extra');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([workloadsExt, workloads2Ext]);
+
+    const { result } = renderHook(() => useNavExtensionsForSection('workloads'));
+
+    expect(result.current).toHaveLength(1);
+    expect(result.current[0].properties.id).toBe('pods');
+  });
+
+  it('should memoize result when inputs unchanged', () => {
+    const ext1 = createNavExtension('pods', 'workloads');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([ext1]);
+
+    const { result, rerender } = renderHook(() => useNavExtensionsForSection('workloads'));
+    const firstResult = result.current;
+
+    rerender();
+
+    expect(result.current).toBe(firstResult);
+  });
+
+  it('should update result when extensions change', () => {
+    const ext1 = createNavExtension('pods', 'workloads');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([ext1]);
+
+    const { result, rerender } = renderHook(() => useNavExtensionsForSection('workloads'));
+    const firstResult = result.current;
+
+    const ext2 = createNavExtension('deployments', 'workloads');
+    (useNavExtensionsForPerspective as jest.Mock).mockReturnValue([ext1, ext2]);
+    rerender();
+
+    expect(result.current).not.toBe(firstResult);
+    expect(result.current).toHaveLength(2);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/__tests__/utils.spec.ts b/frontend/packages/console-app/src/components/nav/__tests__/utils.spec.ts
new file mode 100644
index 00000000000..3e4aeacde13
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nav/__tests__/utils.spec.ts
@@ -0,0 +1,263 @@
+import type { NavExtension, K8sModel } from '@console/dynamic-plugin-sdk';
+import type { LoadedExtension } from '@console/dynamic-plugin-sdk/src/types';
+import {
+  getSortedNavExtensions,
+  sortExtensionItems,
+  stripScopeFromPath,
+  navItemHrefIsActive,
+  navItemResourceIsActive,
+  isTopLevelNavItem,
+} from '../utils';
+
+const createNavExtension = (
+  id: string,
+  overrides: Partial<NavExtension['properties']> = {},
+): LoadedExtension<NavExtension> =>
+  ({
+    type: 'console.navigation/href',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name: `Nav ${id}`,
+      href: `/${id}`,
+      ...overrides,
+    },
+  } as LoadedExtension<NavExtension>);
+
+const createNavSection = (
+  id: string,
+  overrides: Partial<NavExtension['properties']> = {},
+): LoadedExtension<NavExtension> =>
+  ({
+    type: 'console.navigation/section',
+    uid: `uid-${id}`,
+    properties: {
+      id,
+      name: `Section ${id}`,
+      ...overrides,
+    },
+  } as LoadedExtension<NavExtension>);
+
+describe('utils', () => {
+  describe('stripScopeFromPath', () => {
+    it('should strip k8s/cluster/ prefix from path', () => {
+      expect(stripScopeFromPath('/k8s/cluster/nodes')).toBe('nodes');
+    });
+
+    it('should strip k8s/ns/<namespace>/ prefix from path', () => {
+      expect(stripScopeFromPath('/k8s/ns/default/pods')).toBe('pods');
+    });
+
+    it('should strip k8s/all-namespaces/ prefix from path', () => {
+      expect(stripScopeFromPath('/k8s/all-namespaces/deployments')).toBe('deployments');
+    });
+
+    it('should handle paths without k8s scope', () => {
+      expect(stripScopeFromPath('/monitoring/alerts')).toBe('monitoring/alerts');
+    });
+
+    it('should handle trailing slashes', () => {
+      expect(stripScopeFromPath('/k8s/cluster/nodes/')).toBe('nodes');
+    });
+
+    it('should handle complex namespace names', () => {
+      expect(stripScopeFromPath('/k8s/ns/my-project-123/configmaps')).toBe('configmaps');
+    });
+  });
+
+  describe('navItemHrefIsActive', () => {
+    it('should return true when location matches href exactly', () => {
+      expect(navItemHrefIsActive('/k8s/cluster/nodes', '/k8s/cluster/nodes')).toBe(true);
+    });
+
+    it('should return true when location starts with href segments', () => {
+      expect(navItemHrefIsActive('/k8s/cluster/nodes/node-1', '/k8s/cluster/nodes')).toBe(true);
+    });
+
+    it('should return false when location does not match href', () => {
+      expect(navItemHrefIsActive('/k8s/cluster/pods', '/k8s/cluster/nodes')).toBe(false);
+    });
+
+    it('should return true when location matches startsWith array', () => {
+      expect(navItemHrefIsActive('/monitoring/alerts', '/monitoring', ['monitoring/alerts'])).toBe(
+        true,
+      );
+    });
+
+    it('should handle namespaced paths correctly', () => {
+      expect(navItemHrefIsActive('/k8s/ns/default/pods', '/k8s/ns/test/pods')).toBe(true);
+    });
+
+    it('should return false when startsWith does not match', () => {
+      expect(navItemHrefIsActive('/other/path', '/monitoring', ['monitoring/alerts'])).toBe(false);
+    });
+  });
+
+  describe('navItemResourceIsActive', () => {
+    const mockK8sModel: K8sModel = {
+      apiVersion: 'v1',
+      apiGroup: '',
+      kind: 'Pod',
+      label: 'Pod',
+      labelPlural: 'Pods',
+      plural: 'pods',
+      abbr: 'P',
+      namespaced: true,
+    };
+
+    it('should return true when location matches model plural', () => {
+      expect(navItemResourceIsActive('/k8s/ns/default/pods', mockK8sModel)).toBe(true);
+    });
+
+    it('should return false when location does not match model', () => {
+      expect(navItemResourceIsActive('/k8s/ns/default/deployments', mockK8sModel)).toBe(false);
+    });
+
+    it('should return true when location matches startsWith', () => {
+      expect(navItemResourceIsActive('/workloads/pods', mockK8sModel, ['workloads'])).toBe(true);
+    });
+
+    it('should return false when model is undefined', () => {
+      expect(navItemResourceIsActive('/k8s/ns/default/pods', undefined)).toBe(false);
+    });
+
+    it('should handle cluster-scoped resources', () => {
+      const clusterModel: K8sModel = {
+        apiVersion: 'v1',
+        apiGroup: '',
+        kind: 'Node',
+        label: 'Node',
+        labelPlural: 'Nodes',
+        plural: 'nodes',
+        abbr: 'N',
+        namespaced: false,
+      };
+      expect(navItemResourceIsActive('/k8s/cluster/nodes', clusterModel)).toBe(true);
+    });
+  });
+
+  describe('getSortedNavExtensions', () => {
+    it('should return items in original order when no positioning specified', () => {
+      const items = [createNavExtension('a'), createNavExtension('b'), createNavExtension('c')];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted.map((i) => i.properties.id)).toEqual(['a', 'b', 'c']);
+    });
+
+    it('should position item before another using insertBefore', () => {
+      const items = [
+        createNavExtension('a'),
+        createNavExtension('b'),
+        createNavExtension('c', { insertBefore: 'a' }),
+      ];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted.map((i) => i.properties.id)).toEqual(['c', 'a', 'b']);
+    });
+
+    it('should position item after another using insertAfter', () => {
+      const items = [
+        createNavExtension('a'),
+        createNavExtension('b'),
+        createNavExtension('c', { insertAfter: 'a' }),
+      ];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted.map((i) => i.properties.id)).toEqual(['a', 'c', 'b']);
+    });
+
+    it('should handle insertBefore with array of targets', () => {
+      const items = [
+        createNavExtension('a'),
+        createNavExtension('b'),
+        createNavExtension('c', { insertBefore: ['nonexistent', 'b'] }),
+      ];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted.map((i) => i.properties.id)).toEqual(['a', 'c', 'b']);
+    });
+
+    it('should handle insertAfter with array of targets', () => {
+      const items = [
+        createNavExtension('a'),
+        createNavExtension('b'),
+        createNavExtension('c', { insertAfter: ['nonexistent', 'a'] }),
+      ];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted.map((i) => i.properties.id)).toEqual(['a', 'c', 'b']);
+    });
+
+    it('should handle circular dependencies gracefully', () => {
+      const items = [
+        createNavExtension('a', { insertAfter: 'b' }),
+        createNavExtension('b', { insertAfter: 'a' }),
+      ];
+
+      const sorted = getSortedNavExtensions(items);
+
+      expect(sorted).toHaveLength(2);
+      expect(sorted.map((i) => i.properties.id)).toContain('a');
+      expect(sorted.map((i) => i.properties.id)).toContain('b');
+    });
+  });
+
+  describe('sortExtensionItems', () => {
+    it('should return empty array for empty input', () => {
+      expect(sortExtensionItems([])).toEqual([]);
+    });
+
+    it('should return single item unchanged', () => {
+      const items = [createNavExtension('a')];
+      const sorted = sortExtensionItems(items);
+      expect(sorted.map((i) => i.properties.id)).toEqual(['a']);
+    });
+
+    it('should sort items based on dependencies', () => {
+      const items = [
+        createNavExtension('c', { insertAfter: 'b' }),
+        createNavExtension('a'),
+        createNavExtension('b', { insertAfter: 'a' }),
+      ];
+
+      const sorted = sortExtensionItems(items);
+
+      const aIndex = sorted.findIndex((i) => i.properties.id === 'a');
+      const bIndex = sorted.findIndex((i) => i.properties.id === 'b');
+      const cIndex = sorted.findIndex((i) => i.properties.id === 'c');
+
+      expect(aIndex).toBeLessThan(bIndex);
+      expect(bIndex).toBeLessThan(cIndex);
+    });
+
+    it('should handle items with no dependencies first', () => {
+      const items = [createNavExtension('b', { insertAfter: 'a' }), createNavExtension('a')];
+
+      const sorted = sortExtensionItems(items);
+
+      expect(sorted[0].properties.id).toBe('a');
+    });
+  });
+
+  describe('isTopLevelNavItem', () => {
+    it('should return true for nav sections', () => {
+      const section = createNavSection('home');
+      expect(isTopLevelNavItem(section)).toBe(true);
+    });
+
+    it('should return true for items without section property', () => {
+      const item = createNavExtension('dashboard');
+      expect(isTopLevelNavItem(item)).toBe(true);
+    });
+
+    it('should return false for items with section property', () => {
+      const item = createNavExtension('pods', { section: 'workloads' });
+      expect(isTopLevelNavItem(item)).toBe(false);
+    });
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nav/index.tsx b/frontend/packages/console-app/src/components/nav/index.tsx
index 062b29defff..393920a96b8 100644
--- a/frontend/packages/console-app/src/components/nav/index.tsx
+++ b/frontend/packages/console-app/src/components/nav/index.tsx
@@ -15,7 +15,7 @@ export const Navigation = memo<NavigationProps>(
   ({ isNavOpen, onNavSelect, onPerspectiveSelected }) => {
     const { t } = useTranslation();
     return (
-      <PageSidebar isSidebarOpen={isNavOpen}>
+      <PageSidebar isSidebarOpen={isNavOpen} data-test="navigation-page-sidebar">
         <PageSidebarBody>
           <Nav aria-label={t('console-app~Nav')} onSelect={onNavSelect}>
             <NavHeader onPerspectiveSelected={onPerspectiveSelected} />
diff --git a/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsConditions.spec.tsx b/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsConditions.spec.tsx
new file mode 100644
index 00000000000..66bd700b75f
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsConditions.spec.tsx
@@ -0,0 +1,141 @@
+import { render, screen } from '@testing-library/react';
+import type { NodeKind } from '@console/internal/module/k8s';
+import NodeDetailsConditions from '../NodeDetailsConditions';
+
+jest.mock('@console/internal/components/utils/headings', () => ({
+  SectionHeading: ({ text }: { text: string }) => <h2>{text}</h2>,
+}));
+
+jest.mock('@console/shared/src/components/layout/PaneBody', () => ({
+  __esModule: true,
+  default: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+
+jest.mock('@console/shared/src/components/datetime/Timestamp', () => ({
+  Timestamp: ({ timestamp }: { timestamp: string }) => <span>{timestamp}</span>,
+}));
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  CamelCaseWrap: ({ value }: { value: string }) => <span>{value}</span>,
+}));
+
+describe('NodeDetailsConditions', () => {
+  const createMockNode = (conditions: any[] = []): NodeKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'Node',
+      metadata: {
+        name: 'test-node',
+      },
+      status: {
+        conditions,
+      },
+    } as NodeKind);
+
+  it('should render section heading', () => {
+    const node = createMockNode([]);
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByRole('heading', { name: 'Node conditions' })).toBeVisible();
+  });
+
+  it('should render table headers', () => {
+    const node = createMockNode([]);
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByRole('columnheader', { name: 'Type' })).toBeVisible();
+    expect(screen.getByRole('columnheader', { name: 'Status' })).toBeVisible();
+    expect(screen.getByRole('columnheader', { name: 'Reason' })).toBeVisible();
+    expect(screen.getByRole('columnheader', { name: 'Updated' })).toBeVisible();
+    expect(screen.getByRole('columnheader', { name: 'Changed' })).toBeVisible();
+  });
+
+  it('should display condition type', () => {
+    const node = createMockNode([
+      {
+        type: 'Ready',
+        status: 'True',
+        reason: 'KubeletReady',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+    ]);
+
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByText('Ready')).toBeVisible();
+  });
+
+  it('should display condition status', () => {
+    const node = createMockNode([
+      {
+        type: 'Ready',
+        status: 'True',
+        reason: 'KubeletReady',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+    ]);
+
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByText('True')).toBeVisible();
+  });
+
+  it('should display dash for missing status', () => {
+    const node = createMockNode([
+      {
+        type: 'MemoryPressure',
+        status: '',
+        reason: '',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+    ]);
+
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display multiple conditions', () => {
+    const node = createMockNode([
+      {
+        type: 'Ready',
+        status: 'True',
+        reason: 'KubeletReady',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+      {
+        type: 'MemoryPressure',
+        status: 'False',
+        reason: 'KubeletHasSufficientMemory',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+    ]);
+
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByText('Ready')).toBeVisible();
+    expect(screen.getByText('MemoryPressure')).toBeVisible();
+  });
+
+  it('should display timestamps', () => {
+    const node = createMockNode([
+      {
+        type: 'Ready',
+        status: 'True',
+        reason: 'KubeletReady',
+        lastHeartbeatTime: '2024-01-15T10:00:00Z',
+        lastTransitionTime: '2024-01-14T08:00:00Z',
+      },
+    ]);
+
+    render(<NodeDetailsConditions node={node} />);
+
+    expect(screen.getByText('2024-01-15T10:00:00Z')).toBeVisible();
+    expect(screen.getByText('2024-01-14T08:00:00Z')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsImages.spec.tsx b/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsImages.spec.tsx
new file mode 100644
index 00000000000..a71dc0f6ab0
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/__tests__/NodeDetailsImages.spec.tsx
@@ -0,0 +1,117 @@
+import { render, screen } from '@testing-library/react';
+import type { NodeKind } from '@console/internal/module/k8s';
+import NodeDetailsImages from '../NodeDetailsImages';
+
+jest.mock('@console/internal/components/utils/headings', () => ({
+  SectionHeading: ({ text }: { text: string }) => <h2>{text}</h2>,
+}));
+
+jest.mock('@console/shared/src/components/layout/PaneBody', () => ({
+  __esModule: true,
+  default: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+
+describe('NodeDetailsImages', () => {
+  const createMockNode = (images: any[] = []): NodeKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'Node',
+      metadata: {
+        name: 'test-node',
+      },
+      status: {
+        images,
+      },
+    } as NodeKind);
+
+  it('should render section heading', () => {
+    const node = createMockNode([]);
+    render(<NodeDetailsImages node={node} />);
+
+    expect(screen.getByRole('heading', { name: 'Images' })).toBeVisible();
+  });
+
+  it('should render table headers', () => {
+    const node = createMockNode([]);
+    render(<NodeDetailsImages node={node} />);
+
+    expect(screen.getByRole('columnheader', { name: 'Name' })).toBeVisible();
+    expect(screen.getByRole('columnheader', { name: 'Size' })).toBeVisible();
+  });
+
+  it('should display image names and sizes', () => {
+    const node = createMockNode([
+      {
+        names: ['nginx:latest', 'nginx@sha256:abc123'],
+        sizeBytes: 141516288,
+      },
+    ]);
+
+    render(<NodeDetailsImages node={node} />);
+
+    // Should display the name without @ or <none>
+    expect(screen.getByText('nginx:latest')).toBeVisible();
+    // Should display humanized size
+    expect(screen.getByText('135 MiB')).toBeVisible();
+  });
+
+  it('should prefer image name without @ symbol', () => {
+    const node = createMockNode([
+      {
+        names: ['nginx@sha256:abc123', 'nginx:1.21'],
+        sizeBytes: 1024,
+      },
+    ]);
+
+    render(<NodeDetailsImages node={node} />);
+
+    expect(screen.getByText('nginx:1.21')).toBeVisible();
+    expect(screen.queryByText('nginx@sha256:abc123')).not.toBeInTheDocument();
+  });
+
+  it('should fallback to first name if all contain @ or <none>', () => {
+    const node = createMockNode([
+      {
+        names: ['<none>@<none>', 'image@sha256:def456'],
+        sizeBytes: 2048,
+      },
+    ]);
+
+    render(<NodeDetailsImages node={node} />);
+
+    expect(screen.getByText('<none>@<none>')).toBeVisible();
+  });
+
+  it('should filter out images without names', () => {
+    const node = createMockNode([
+      {
+        names: ['valid-image:latest'],
+        sizeBytes: 1024,
+      },
+      {
+        names: null,
+        sizeBytes: 2048,
+      },
+    ]);
+
+    render(<NodeDetailsImages node={node} />);
+
+    const rows = screen.getAllByRole('row');
+    // Header row + 1 data row (filtered out the one without names)
+    expect(rows).toHaveLength(2);
+  });
+
+  it('should display zero bytes for zero size', () => {
+    const node = createMockNode([
+      {
+        names: ['image:latest'],
+        sizeBytes: 0,
+      },
+    ]);
+
+    render(<NodeDetailsImages node={node} />);
+
+    // humanizeBinaryBytes(0) returns "0 B"
+    expect(screen.getByText('0 B')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nodes/__tests__/NodeIPList.spec.tsx b/frontend/packages/console-app/src/components/nodes/__tests__/NodeIPList.spec.tsx
new file mode 100644
index 00000000000..4ab4244b866
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/__tests__/NodeIPList.spec.tsx
@@ -0,0 +1,71 @@
+import { render, screen } from '@testing-library/react';
+import NodeIPList from '../NodeIPList';
+
+describe('NodeIPList', () => {
+  const mockIps = [
+    { type: 'InternalIP', address: '10.0.0.1' },
+    { type: 'ExternalIP', address: '192.168.1.1' },
+    { type: 'Hostname', address: 'node-1.example.com' },
+  ];
+
+  it('should only show InternalIP by default', () => {
+    render(<NodeIPList ips={mockIps} />);
+
+    expect(screen.getByText('10.0.0.1')).toBeVisible();
+    expect(screen.queryByText('192.168.1.1')).not.toBeInTheDocument();
+    expect(screen.queryByText('node-1.example.com')).not.toBeInTheDocument();
+  });
+
+  it('should show all IP types when expand is true', () => {
+    render(<NodeIPList ips={mockIps} expand />);
+
+    expect(screen.getByText('10.0.0.1')).toBeVisible();
+    expect(screen.getByText('192.168.1.1')).toBeVisible();
+    expect(screen.getByText('node-1.example.com')).toBeVisible();
+  });
+
+  it('should display IP type labels correctly', () => {
+    render(<NodeIPList ips={mockIps} expand />);
+
+    // Type names should be formatted with spaces (InternalIP -> Internal IP)
+    // The component adds ": " after the title
+    expect(screen.getByText(/Internal IP/)).toBeVisible();
+    expect(screen.getByText(/External IP/)).toBeVisible();
+    expect(screen.getByText(/Hostname/)).toBeVisible();
+  });
+
+  it('should sort IPs by type', () => {
+    const unorderedIps = [
+      { type: 'Hostname', address: 'host' },
+      { type: 'ExternalIP', address: '192.168.1.1' },
+      { type: 'InternalIP', address: '10.0.0.1' },
+    ];
+
+    render(<NodeIPList ips={unorderedIps} expand />);
+
+    const items = screen.getAllByRole('listitem');
+    // Should be sorted: ExternalIP, Hostname, InternalIP (alphabetically by type)
+    expect(items[0]).toHaveTextContent('External IP');
+    expect(items[1]).toHaveTextContent('Hostname');
+    expect(items[2]).toHaveTextContent('Internal IP');
+  });
+
+  it('should handle empty address gracefully', () => {
+    const ipsWithEmpty = [
+      { type: 'InternalIP', address: '10.0.0.1' },
+      { type: 'ExternalIP', address: '' },
+    ];
+
+    render(<NodeIPList ips={ipsWithEmpty} expand />);
+
+    expect(screen.getByText('10.0.0.1')).toBeVisible();
+    // Empty address should not be rendered
+    expect(screen.queryByText('External IP')).not.toBeInTheDocument();
+  });
+
+  it('should handle empty ips array', () => {
+    render(<NodeIPList ips={[]} />);
+
+    expect(screen.queryByRole('listitem')).not.toBeInTheDocument();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nodes/__tests__/NodeRoles.spec.tsx b/frontend/packages/console-app/src/components/nodes/__tests__/NodeRoles.spec.tsx
new file mode 100644
index 00000000000..abcc03fcaed
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/__tests__/NodeRoles.spec.tsx
@@ -0,0 +1,63 @@
+import { render, screen } from '@testing-library/react';
+import type { NodeKind } from '@console/internal/module/k8s';
+import { getNodeRoles } from '@console/shared/src/selectors/node';
+import NodeRoles from '../NodeRoles';
+
+jest.mock('@console/shared/src/selectors/node', () => ({
+  getNodeRoles: jest.fn(),
+}));
+
+const mockGetNodeRoles = getNodeRoles as jest.Mock;
+
+describe('NodeRoles', () => {
+  const createMockNode = (): NodeKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'Node',
+      metadata: { name: 'test-node' },
+    } as NodeKind);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display single role', () => {
+    mockGetNodeRoles.mockReturnValue(['worker']);
+
+    render(<NodeRoles node={createMockNode()} />);
+
+    expect(screen.getByText('worker')).toBeVisible();
+  });
+
+  it('should display multiple roles sorted alphabetically', () => {
+    mockGetNodeRoles.mockReturnValue(['worker', 'infra', 'control-plane']);
+
+    render(<NodeRoles node={createMockNode()} />);
+
+    expect(screen.getByText('control-plane, infra, worker')).toBeVisible();
+  });
+
+  it('should display dash when no roles', () => {
+    mockGetNodeRoles.mockReturnValue([]);
+
+    render(<NodeRoles node={createMockNode()} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display dash when node is undefined', () => {
+    mockGetNodeRoles.mockReturnValue([]);
+
+    render(<NodeRoles node={undefined} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should handle master and worker roles', () => {
+    mockGetNodeRoles.mockReturnValue(['master', 'worker']);
+
+    render(<NodeRoles node={createMockNode()} />);
+
+    expect(screen.getByText('master, worker')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nodes/modals/__tests__/GroupsEditorModal.spec.tsx b/frontend/packages/console-app/src/components/nodes/modals/__tests__/GroupsEditorModal.spec.tsx
index 39682c5f408..8f9a7b654ca 100644
--- a/frontend/packages/console-app/src/components/nodes/modals/__tests__/GroupsEditorModal.spec.tsx
+++ b/frontend/packages/console-app/src/components/nodes/modals/__tests__/GroupsEditorModal.spec.tsx
@@ -131,8 +131,7 @@ describe('GroupsEditorModal', () => {
       const groupAButton = screen.getByRole('button', { name: 'group-a' });
       await user.click(groupAButton);
 
-      const groupAButton2 = screen.getByRole('button', { name: 'group-a' });
-      expect(groupAButton2).toHaveClass('pf-m-current');
+      expect(screen.getByText('Nodes for group group-a')).toBeVisible();
     });
 
     it('displays nodes for selected group', async () => {
@@ -250,8 +249,7 @@ describe('GroupsEditorModal', () => {
       const input = screen.getByPlaceholderText('Enter a group name');
       await user.type(input, 'auto-select{enter}');
 
-      const newGroupButton = screen.getByRole('button', { name: 'auto-select' });
-      expect(newGroupButton).toHaveClass('pf-m-current');
+      expect(screen.getByText('Nodes for group auto-select')).toBeInTheDocument();
     });
 
     it('clears input after adding group', async () => {
diff --git a/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/BareMetalInventoryItems.spec.tsx b/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/BareMetalInventoryItems.spec.tsx
index 3e094a7a961..f1d6a5dce7f 100644
--- a/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/BareMetalInventoryItems.spec.tsx
+++ b/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/BareMetalInventoryItems.spec.tsx
@@ -37,7 +37,9 @@ jest.mock('@console/shared/src', () => ({
 
 jest.mock('@console/shared/src/components/dashboard/inventory-card/InventoryItem', () => ({
   InventoryItem: jest.fn(({ title, count, isLoading }) => (
-    <div data-testid="inventory-item">{isLoading ? 'Loading...' : `${title}: ${count}`}</div>
+    <span role="status" aria-label={title}>
+      {isLoading ? 'Loading...' : `${title}: ${count}`}
+    </span>
   )),
 }));
 
@@ -106,7 +108,7 @@ describe('BareMetalInventoryItems', () => {
 
     renderWithContext();
 
-    expect(screen.queryByTestId('inventory-item')).not.toBeInTheDocument();
+    expect(screen.queryByRole('status', { name: 'Disk' })).not.toBeInTheDocument();
   });
 
   it('should show loading state when data is loading', () => {
diff --git a/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/NodeUptime.spec.tsx b/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/NodeUptime.spec.tsx
new file mode 100644
index 00000000000..8176d117bb4
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/node-dashboard/__tests__/NodeUptime.spec.tsx
@@ -0,0 +1,79 @@
+import { render, screen } from '@testing-library/react';
+import type { NodeKind } from '@console/internal/module/k8s';
+import { getNodeUptime } from '@console/shared/src';
+import NodeUptime from '../NodeUptime';
+
+jest.mock('@console/shared/src', () => ({
+  getNodeUptime: jest.fn(),
+}));
+
+jest.mock('@console/shared/src/components/datetime/Timestamp', () => ({
+  Timestamp: ({ timestamp }: { timestamp: string }) => (
+    <span data-test="timestamp">{timestamp || 'No timestamp'}</span>
+  ),
+}));
+
+const mockGetNodeUptime = getNodeUptime as jest.Mock;
+
+describe('NodeUptime', () => {
+  const createMockNode = (): NodeKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'Node',
+      metadata: { name: 'test-node' },
+      status: {
+        conditions: [
+          {
+            type: 'Ready',
+            status: 'True',
+            lastTransitionTime: '2024-01-15T10:00:00Z',
+          },
+        ],
+      },
+    } as NodeKind);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display timestamp from node uptime', () => {
+    mockGetNodeUptime.mockReturnValue('2024-01-15T10:00:00Z');
+
+    render(<NodeUptime obj={createMockNode()} />);
+
+    expect(screen.getByTestId('timestamp')).toHaveTextContent('2024-01-15T10:00:00Z');
+  });
+
+  it('should pass node object to getNodeUptime', () => {
+    const node = createMockNode();
+    mockGetNodeUptime.mockReturnValue('2024-01-15T10:00:00Z');
+
+    render(<NodeUptime obj={node} />);
+
+    expect(mockGetNodeUptime).toHaveBeenCalledWith(node);
+  });
+
+  it('should handle undefined uptime gracefully', () => {
+    mockGetNodeUptime.mockReturnValue(undefined);
+
+    render(<NodeUptime obj={createMockNode()} />);
+
+    expect(screen.getByTestId('timestamp')).toHaveTextContent('No timestamp');
+  });
+
+  it('should handle empty string uptime', () => {
+    mockGetNodeUptime.mockReturnValue('');
+
+    render(<NodeUptime obj={createMockNode()} />);
+
+    expect(screen.getByTestId('timestamp')).toHaveTextContent('No timestamp');
+  });
+
+  it('should render with different timestamp formats', () => {
+    mockGetNodeUptime.mockReturnValue('2023-12-25T00:00:00Z');
+
+    render(<NodeUptime obj={createMockNode()} />);
+
+    expect(screen.getByTestId('timestamp')).toHaveTextContent('2023-12-25T00:00:00Z');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/nodes/status/__tests__/SchedulableStatus.spec.tsx b/frontend/packages/console-app/src/components/nodes/status/__tests__/SchedulableStatus.spec.tsx
new file mode 100644
index 00000000000..2fde748af49
--- /dev/null
+++ b/frontend/packages/console-app/src/components/nodes/status/__tests__/SchedulableStatus.spec.tsx
@@ -0,0 +1,111 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { NodeKind } from '@console/internal/module/k8s';
+import * as nodesRequestModule from '../../../../k8s/requests/nodes';
+import { isUnschedulableActive, MarkAsSchedulablePopover } from '../SchedulableStatus';
+
+jest.mock('../../../../k8s/requests/nodes', () => ({
+  makeNodeSchedulable: jest.fn(),
+}));
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  StatusIconAndText: ({ title, icon }: { title: string; icon: React.ReactNode }) => (
+    <div role="status" aria-live="polite">
+      {icon}
+      {title}
+    </div>
+  ),
+  YellowExclamationTriangleIcon: () => <span role="img" aria-label="Warning" />,
+}));
+
+jest.mock('@console/dynamic-plugin-sdk/src/app/modal-support/useOverlay', () => ({
+  useOverlay: () => jest.fn(),
+}));
+
+const mockMakeNodeSchedulable = nodesRequestModule.makeNodeSchedulable as jest.Mock;
+
+describe('SchedulableStatus', () => {
+  const createMockNode = (unschedulable: boolean = false): NodeKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'Node',
+      metadata: {
+        name: 'test-node',
+      },
+      spec: {
+        unschedulable,
+      },
+    } as NodeKind);
+
+  describe('isUnschedulableActive', () => {
+    it('should return true when node is unschedulable', () => {
+      const node = createMockNode(true);
+      expect(isUnschedulableActive(node, {})).toBe(true);
+    });
+
+    it('should return false when node is schedulable', () => {
+      const node = createMockNode(false);
+      expect(isUnschedulableActive(node, {})).toBe(false);
+    });
+
+    it('should return false when unschedulable is undefined', () => {
+      const node: NodeKind = {
+        apiVersion: 'v1',
+        kind: 'Node',
+        metadata: { name: 'test-node' },
+        spec: {},
+      } as NodeKind;
+      expect(isUnschedulableActive(node, {})).toBe(false);
+    });
+  });
+
+  describe('MarkAsSchedulablePopover', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should display scheduling disabled status', () => {
+      const node = createMockNode(true);
+      render(<MarkAsSchedulablePopover node={node} resources={{}} />);
+
+      expect(screen.getByRole('status')).toHaveTextContent('Scheduling disabled');
+    });
+
+    it('should display warning icon', () => {
+      const node = createMockNode(true);
+      render(<MarkAsSchedulablePopover node={node} resources={{}} />);
+
+      expect(screen.getByRole('img', { name: 'Warning' })).toBeVisible();
+    });
+
+    it('should display explanation text', () => {
+      const node = createMockNode(true);
+      render(<MarkAsSchedulablePopover node={node} resources={{}} />);
+
+      expect(
+        screen.getByText(
+          /No new Pods or workloads will be placed on this Node until it's marked as schedulable/,
+        ),
+      ).toBeVisible();
+    });
+
+    it('should display mark as schedulable button', () => {
+      const node = createMockNode(true);
+      render(<MarkAsSchedulablePopover node={node} resources={{}} />);
+
+      expect(screen.getByRole('button', { name: 'Mark as schedulable' })).toBeVisible();
+    });
+
+    it('should call makeNodeSchedulable when button is clicked', async () => {
+      const user = userEvent.setup();
+      mockMakeNodeSchedulable.mockResolvedValue({});
+      const node = createMockNode(true);
+      render(<MarkAsSchedulablePopover node={node} resources={{}} />);
+
+      const button = screen.getByRole('button', { name: 'Mark as schedulable' });
+      await user.click(button);
+
+      expect(mockMakeNodeSchedulable).toHaveBeenCalledWith(node);
+    });
+  });
+});
diff --git a/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityDisplay.spec.tsx b/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityDisplay.spec.tsx
new file mode 100644
index 00000000000..f1d432e2458
--- /dev/null
+++ b/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityDisplay.spec.tsx
@@ -0,0 +1,95 @@
+import { render, screen } from '@testing-library/react';
+import AvailabilityDisplay from '../AvailabilityDisplay';
+import type { PodDisruptionBudgetKind } from '../types';
+
+describe('AvailabilityDisplay', () => {
+  const basePdb: PodDisruptionBudgetKind = {
+    apiVersion: 'policy/v1',
+    kind: 'PodDisruptionBudget',
+    metadata: {
+      name: 'test-pdb',
+      namespace: 'default',
+    },
+    spec: {
+      selector: { matchLabels: { app: 'test' } },
+    },
+  };
+
+  it('should display dash when neither minAvailable nor maxUnavailable is set', () => {
+    render(<AvailabilityDisplay pdb={basePdb} />);
+
+    expect(screen.getByText('-')).toBeVisible();
+  });
+
+  it('should display minAvailable when only minAvailable is set', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: 2,
+      },
+    };
+
+    render(<AvailabilityDisplay pdb={pdb} />);
+
+    expect(screen.getByText(/Min available 2/)).toBeVisible();
+  });
+
+  it('should display maxUnavailable when only maxUnavailable is set', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        maxUnavailable: 1,
+      },
+    };
+
+    render(<AvailabilityDisplay pdb={pdb} />);
+
+    expect(screen.getByText(/Max unavailable 1/)).toBeVisible();
+  });
+
+  it('should display maxUnavailable when both are set (maxUnavailable takes precedence)', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: 3,
+        maxUnavailable: 1,
+      },
+    };
+
+    render(<AvailabilityDisplay pdb={pdb} />);
+
+    // Logic: if maxUnavailable is not nil, show maxUnavailable
+    expect(screen.getByText(/Max unavailable 1/)).toBeVisible();
+  });
+
+  it('should handle percentage values', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: '50%',
+      },
+    };
+
+    render(<AvailabilityDisplay pdb={pdb} />);
+
+    expect(screen.getByText(/Min available 50%/)).toBeVisible();
+  });
+
+  it('should handle string number values', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        maxUnavailable: '2',
+      },
+    };
+
+    render(<AvailabilityDisplay pdb={pdb} />);
+
+    expect(screen.getByText(/Max unavailable 2/)).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityRequirement.spec.tsx b/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityRequirement.spec.tsx
new file mode 100644
index 00000000000..615c97ee28b
--- /dev/null
+++ b/frontend/packages/console-app/src/components/pdb/__tests__/AvailabilityRequirement.spec.tsx
@@ -0,0 +1,103 @@
+import { render, screen } from '@testing-library/react';
+import AvailabilityRequirement from '../AvailabilityRequirement';
+import type { PodDisruptionBudgetKind } from '../types';
+
+describe('AvailabilityRequirement', () => {
+  const basePdb: PodDisruptionBudgetKind = {
+    apiVersion: 'policy/v1',
+    kind: 'PodDisruptionBudget',
+    metadata: {
+      name: 'test-pdb',
+      namespace: 'default',
+    },
+    spec: {
+      selector: { matchLabels: { app: 'test' } },
+    },
+  };
+
+  it('should display minAvailable message when minAvailable is set', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: 2,
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={3} />);
+
+    expect(screen.getByText(/Min available 2 of 3 pod/)).toBeVisible();
+  });
+
+  it('should display maxUnavailable message when maxUnavailable is set', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        maxUnavailable: 1,
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={5} />);
+
+    expect(screen.getByText(/Max unavailable 1 of 5 pod/)).toBeVisible();
+  });
+
+  it('should handle percentage values for minAvailable', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: '50%',
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={4} />);
+
+    expect(screen.getByText(/Min available 50% of 4 pod/)).toBeVisible();
+  });
+
+  it('should handle percentage values for maxUnavailable', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        maxUnavailable: '25%',
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={8} />);
+
+    expect(screen.getByText(/Max unavailable 25% of 8 pod/)).toBeVisible();
+  });
+
+  it('should prefer minAvailable over maxUnavailable when both are set', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: 3,
+        maxUnavailable: 1,
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={4} />);
+
+    expect(screen.getByText(/Min available 3 of 4 pod/)).toBeVisible();
+    expect(screen.queryByText(/Max unavailable/)).not.toBeInTheDocument();
+  });
+
+  it('should handle single replica', () => {
+    const pdb: PodDisruptionBudgetKind = {
+      ...basePdb,
+      spec: {
+        ...basePdb.spec,
+        minAvailable: 1,
+      },
+    };
+
+    render(<AvailabilityRequirement pdb={pdb} replicas={1} />);
+
+    expect(screen.getByText(/Min available 1 of 1 pod/)).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/pdb/__tests__/DisruptionsAllowed.spec.tsx b/frontend/packages/console-app/src/components/pdb/__tests__/DisruptionsAllowed.spec.tsx
new file mode 100644
index 00000000000..8e917ccbdce
--- /dev/null
+++ b/frontend/packages/console-app/src/components/pdb/__tests__/DisruptionsAllowed.spec.tsx
@@ -0,0 +1,85 @@
+import { render, screen } from '@testing-library/react';
+import DisruptionsAllowed from '../DisruptionsAllowed';
+import type { PodDisruptionBudgetKind } from '../types';
+import * as getPdbResourcesModule from '../utils/get-pdb-resources';
+
+jest.mock('../utils/get-pdb-resources', () => ({
+  isDisruptionViolated: jest.fn(),
+}));
+
+jest.mock('@console/dynamic-plugin-sdk', () => ({
+  YellowExclamationTriangleIcon: () => <span role="img" aria-label="Warning" />,
+}));
+
+const mockIsDisruptionViolated = getPdbResourcesModule.isDisruptionViolated as jest.Mock;
+
+describe('DisruptionsAllowed', () => {
+  const createMockPdb = (disruptionsAllowed: number): PodDisruptionBudgetKind =>
+    ({
+      apiVersion: 'policy/v1',
+      kind: 'PodDisruptionBudget',
+      metadata: {
+        name: 'test-pdb',
+        namespace: 'default',
+      },
+      spec: {
+        selector: { matchLabels: { app: 'test' } },
+      },
+      status: {
+        conditions: [],
+        disruptionsAllowed,
+        currentHealthy: 3,
+        desiredHealthy: 2,
+        expectedPods: 3,
+      },
+    } as PodDisruptionBudgetKind);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display the number of disruptions allowed', () => {
+    mockIsDisruptionViolated.mockReturnValue(false);
+    const pdb = createMockPdb(2);
+
+    render(<DisruptionsAllowed pdb={pdb} />);
+
+    expect(screen.getByText('2')).toBeVisible();
+  });
+
+  it('should display zero disruptions allowed', () => {
+    mockIsDisruptionViolated.mockReturnValue(false);
+    const pdb = createMockPdb(0);
+
+    render(<DisruptionsAllowed pdb={pdb} />);
+
+    expect(screen.getByText('0')).toBeVisible();
+  });
+
+  it('should show warning icon when disruption is violated', () => {
+    mockIsDisruptionViolated.mockReturnValue(true);
+    const pdb = createMockPdb(0);
+
+    render(<DisruptionsAllowed pdb={pdb} />);
+
+    expect(screen.getByRole('img', { name: 'Warning' })).toBeVisible();
+  });
+
+  it('should not show warning icon when disruption is not violated', () => {
+    mockIsDisruptionViolated.mockReturnValue(false);
+    const pdb = createMockPdb(1);
+
+    render(<DisruptionsAllowed pdb={pdb} />);
+
+    expect(screen.queryByRole('img', { name: 'Warning' })).not.toBeInTheDocument();
+  });
+
+  it('should pass pdb to isDisruptionViolated', () => {
+    mockIsDisruptionViolated.mockReturnValue(false);
+    const pdb = createMockPdb(5);
+
+    render(<DisruptionsAllowed pdb={pdb} />);
+
+    expect(mockIsDisruptionViolated).toHaveBeenCalledWith(pdb);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartDrawer.spec.tsx b/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartDrawer.spec.tsx
new file mode 100644
index 00000000000..a8cb7ea5d71
--- /dev/null
+++ b/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartDrawer.spec.tsx
@@ -0,0 +1,88 @@
+import type { QuickStart } from '@patternfly/quickstarts';
+import { render, screen } from '@testing-library/react';
+import { QuickStartDrawer } from '../QuickStartDrawer';
+
+jest.mock('@patternfly/quickstarts', () => ({
+  QuickStartDrawer: ({
+    quickStarts,
+    children,
+    className,
+  }: {
+    quickStarts: QuickStart[];
+    children: React.ReactNode;
+    className: string;
+  }) => (
+    <div data-test="quick-start-drawer" className={className}>
+      <span data-test="quick-start-count">{quickStarts.length}</span>
+      {children}
+    </div>
+  ),
+}));
+
+jest.mock('../loader/QuickStartsLoader', () => ({
+  QuickStartsLoader: ({ children }: { children: (quickStarts: QuickStart[]) => React.ReactNode }) =>
+    children([
+      {
+        apiVersion: 'console.openshift.io/v1',
+        kind: 'QuickStart',
+        metadata: { name: 'test-qs-1' },
+        spec: {
+          displayName: 'Test 1',
+          description: 'Test',
+          durationMinutes: 5,
+          introduction: '',
+          tasks: [],
+        },
+      },
+      {
+        apiVersion: 'console.openshift.io/v1',
+        kind: 'QuickStart',
+        metadata: { name: 'test-qs-2' },
+        spec: {
+          displayName: 'Test 2',
+          description: 'Test',
+          durationMinutes: 10,
+          introduction: '',
+          tasks: [],
+        },
+      },
+    ] as QuickStart[]),
+}));
+
+describe('QuickStartDrawer', () => {
+  it('should render children inside the drawer', () => {
+    render(
+      <QuickStartDrawer>
+        <div data-test="child-content">Child Content</div>
+      </QuickStartDrawer>,
+    );
+
+    expect(screen.getByTestId('child-content')).toHaveTextContent('Child Content');
+  });
+
+  it('should pass quickStarts to PatternFly drawer', () => {
+    render(
+      <QuickStartDrawer>
+        <div>Content</div>
+      </QuickStartDrawer>,
+    );
+
+    expect(screen.getByTestId('quick-start-count')).toHaveTextContent('2');
+  });
+
+  it('should render drawer element', () => {
+    render(
+      <QuickStartDrawer>
+        <div>Content</div>
+      </QuickStartDrawer>,
+    );
+
+    expect(screen.getByTestId('quick-start-drawer')).toBeVisible();
+  });
+
+  it('should render without children', () => {
+    render(<QuickStartDrawer />);
+
+    expect(screen.getByTestId('quick-start-drawer')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartEmptyState.spec.tsx b/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartEmptyState.spec.tsx
new file mode 100644
index 00000000000..a867aece2d4
--- /dev/null
+++ b/frontend/packages/console-app/src/components/quick-starts/__tests__/QuickStartEmptyState.spec.tsx
@@ -0,0 +1,102 @@
+import { render, screen } from '@testing-library/react';
+import * as useAccessReviewModule from '@console/dynamic-plugin-sdk/src/app/components/utils/rbac';
+import { QuickStartEmptyState } from '../QuickStartEmptyState';
+
+jest.mock('@console/dynamic-plugin-sdk/src/app/components/utils/rbac', () => ({
+  useAccessReview: jest.fn(),
+}));
+
+jest.mock('@console/dynamic-plugin-sdk/src/utils/k8s', () => ({
+  getReferenceForModel: jest.fn(() => 'console.openshift.io~v1~QuickStart'),
+}));
+
+jest.mock('@console/internal/components/utils/documentation', () => ({
+  documentationURLs: {
+    creatingQuickStartsTutorials: 'https://docs.example.com/quickstarts',
+  },
+  getDocumentationURL: jest.fn((url) => url),
+}));
+
+jest.mock('@console/shared/src/components/links/ExternalLinkButton', () => ({
+  ExternalLinkButton: ({ children, href }: { children: React.ReactNode; href: string }) => (
+    <a href={href} data-test="external-link">
+      {children}
+    </a>
+  ),
+}));
+
+jest.mock('@console/shared/src/components/links/LinkTo', () => ({
+  LinkTo: (to: string) => ({ children }: { children: React.ReactNode }) => (
+    <a href={to} data-test="internal-link">
+      {children}
+    </a>
+  ),
+}));
+
+const mockUseAccessReview = useAccessReviewModule.useAccessReview as jest.Mock;
+
+describe('QuickStartEmptyState', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should display empty state title', () => {
+    mockUseAccessReview.mockReturnValue([true, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(screen.getByText(/No.*found/)).toBeVisible();
+  });
+
+  it('should show loading skeleton when access review is loading', () => {
+    mockUseAccessReview.mockReturnValue([false, true]);
+
+    render(<QuickStartEmptyState />);
+
+    // When loading, the empty state body shows a skeleton instead of text
+    expect(screen.queryByText(/Configure quick starts/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/Ask a cluster administrator/)).not.toBeInTheDocument();
+  });
+
+  it('should show admin message when user can create quick starts', () => {
+    mockUseAccessReview.mockReturnValue([true, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(
+      screen.getByText(/Configure quick starts to help users get started with the cluster/),
+    ).toBeVisible();
+  });
+
+  it('should show non-admin message when user cannot create quick starts', () => {
+    mockUseAccessReview.mockReturnValue([false, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(screen.getByText(/Ask a cluster administrator to configure quick starts/)).toBeVisible();
+  });
+
+  it('should show configure link when user can create quick starts', () => {
+    mockUseAccessReview.mockReturnValue([true, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(screen.getByText('Configure quick starts')).toBeVisible();
+  });
+
+  it('should not show configure link when user cannot create quick starts', () => {
+    mockUseAccessReview.mockReturnValue([false, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(screen.queryByText('Configure quick starts')).not.toBeInTheDocument();
+  });
+
+  it('should show learn more link when user can create quick starts', () => {
+    mockUseAccessReview.mockReturnValue([true, false]);
+
+    render(<QuickStartEmptyState />);
+
+    expect(screen.getByText('Learn more about quick starts')).toBeVisible();
+  });
+});
diff --git a/frontend/packages/console-app/src/components/quick-starts/loader/__tests__/QuickStartPermissionChecker.spec.tsx b/frontend/packages/console-app/src/components/quick-starts/loader/__tests__/QuickStartPermissionChecker.spec.tsx
new file mode 100644
index 00000000000..d8a64ca4cca
--- /dev/null
+++ b/frontend/packages/console-app/src/components/quick-starts/loader/__tests__/QuickStartPermissionChecker.spec.tsx
@@ -0,0 +1,108 @@
+import type { QuickStart } from '@patternfly/quickstarts';
+import { render, screen, waitFor } from '@testing-library/react';
+import * as useQuickStartPermissionModule from '../../utils/useQuickStartPermission';
+import { QuickStartPermissionChecker } from '../QuickStartPermissionChecker';
+
+jest.mock('../../utils/useQuickStartPermission', () => ({
+  useQuickStartPermission: jest.fn(),
+}));
+
+const mockUseQuickStartPermission = useQuickStartPermissionModule.useQuickStartPermission as jest.Mock;
+
+describe('QuickStartPermissionChecker', () => {
+  const createMockQuickStart = (name: string): QuickStart => ({
+    apiVersion: 'console.openshift.io/v1',
+    kind: 'QuickStart',
+    metadata: {
+      name,
+    },
+    spec: {
+      displayName: `Test ${name}`,
+      description: 'Test description',
+      durationMinutes: 5,
+      icon: null,
+      introduction: 'Test intro',
+      tasks: [],
+    },
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call onPermissionCheck when permission is loaded with true', async () => {
+    mockUseQuickStartPermission.mockReturnValue([true, true]);
+
+    const onPermissionCheck = jest.fn();
+    const quickStart = createMockQuickStart('test-qs');
+
+    render(
+      <QuickStartPermissionChecker quickStart={quickStart} onPermissionCheck={onPermissionCheck} />,
+    );
+
+    // Component renders null; onPermissionCheck runs in useEffect after permission loads.
+    await waitFor(() => {
+      expect(onPermissionCheck).toHaveBeenCalledWith(quickStart, true);
+    });
+  });
+
+  it('should call onPermissionCheck when permission is loaded with false', async () => {
+    mockUseQuickStartPermission.mockReturnValue([false, true]);
+
+    const onPermissionCheck = jest.fn();
+    const quickStart = createMockQuickStart('test-qs');
+
+    render(
+      <QuickStartPermissionChecker quickStart={quickStart} onPermissionCheck={onPermissionCheck} />,
+    );
+
+    // Component renders null; onPermissionCheck runs in useEffect after permission loads.
+    await waitFor(() => {
+      expect(onPermissionCheck).toHaveBeenCalledWith(quickStart, false);
+    });
+  });
+
+  it('should not call onPermissionCheck when permission is not loaded', () => {
+    mockUseQuickStartPermission.mockReturnValue([false, false]);
+
+    const onPermissionCheck = jest.fn();
+    const quickStart = createMockQuickStart('test-qs');
+
+    render(
+      <QuickStartPermissionChecker quickStart={quickStart} onPermissionCheck={onPermissionCheck} />,
+    );
+
+    expect(onPermissionCheck).not.toHaveBeenCalled();
+  });
+
+  it('should render null', () => {
+    mockUseQuickStartPermission.mockReturnValue([true, true]);
+
+    const onPermissionCheck = jest.fn();
+    const quickStart = createMockQuickStart('test-qs');
+
+    render(
+      <div data-test="quickstart-permission-checker-root">
+        <QuickStartPermissionChecker
+          quickStart={quickStart}
+          onPermissionCheck={onPermissionCheck}
+        />
+      </div>,
+    );
+
+    expect(screen.getByTestId('quickstart-permission-checker-root')).toBeEmptyDOMElement();
+  });
+
+  it('should pass quickStart to useQuickStartPermission', () => {
+    mockUseQuickStartPermission.mockReturnValue([false, false]);
+
+    const onPermissionCheck = jest.fn();
+    const quickStart = createMockQuickStart('specific-qs');
+
+    render(
+      <QuickStartPermissionChecker quickStart={quickStart} onPermissionCheck={onPermissionCheck} />,
+    );
+
+    expect(mockUseQuickStartPermission).toHaveBeenCalledWith(quickStart);
+  });
+});
diff --git a/frontend/packages/console-app/src/components/resource-quota/__tests__/ClusterResourceQuotaCharts.spec.tsx b/frontend/packages/console-app/src/components/resource-quota/__tests__/ClusterResourceQuotaCharts.spec.tsx
new file mode 100644
index 00000000000..daa352850fd
--- /dev/null
+++ b/frontend/packages/console-app/src/components/resource-quota/__tests__/ClusterResourceQuotaCharts.spec.tsx
@@ -0,0 +1,115 @@
+import { render, screen } from '@testing-library/react';
+import type { ClusterResourceQuotaKind } from '@console/internal/module/k8s';
+import ClusterResourceQuotaCharts from '../ClusterResourceQuotaCharts';
+
+jest.mock('@console/internal/components/graphs/donut', () => ({
+  DonutChart: ({ title, label }: { title: string; label: string }) => (
+    <div role="group" aria-label={`Cluster resource quota: ${title}`}>
+      <span>{title}</span>
+      <span>{label}</span>
+    </div>
+  ),
+}));
+
+jest.mock('../utils', () => ({
+  getLabelAndUsage: jest.fn(({ used, hard }: { used: string; hard: string }) => ({
+    label: `${used || 0} of ${hard}`,
+    percent: hard ? (parseInt(used || '0', 10) / parseInt(hard, 10)) * 100 : 0,
+  })),
+}));
+
+describe('ClusterResourceQuotaCharts', () => {
+  const createMockQuota = (
+    hardResources: Record<string, string> = {},
+    usedResources: Record<string, string> = {},
+  ): ClusterResourceQuotaKind =>
+    ({
+      apiVersion: 'quota.openshift.io/v1',
+      kind: 'ClusterResourceQuota',
+      metadata: {
+        name: 'test-crq',
+      },
+      status: {
+        total: {
+          hard: hardResources,
+          used: usedResources,
+        },
+      },
+    } as ClusterResourceQuotaKind);
+
+  it('should display "No quota" when no hard quotas are set', () => {
+    const quota = createMockQuota({}, {});
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(screen.getByText('No quota')).toBeVisible();
+  });
+
+  it('should display "No quota" when status is undefined', () => {
+    const quota: ClusterResourceQuotaKind = {
+      apiVersion: 'quota.openshift.io/v1',
+      kind: 'ClusterResourceQuota',
+      metadata: {
+        name: 'test-crq',
+      },
+    } as ClusterResourceQuotaKind;
+
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(screen.getByText('No quota')).toBeVisible();
+  });
+
+  it('should render donut chart for each resource', () => {
+    const quota = createMockQuota({ pods: '10', secrets: '20' }, { pods: '5', secrets: '10' });
+
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(screen.getAllByRole('group', { name: /Cluster resource quota:/ })).toHaveLength(2);
+  });
+
+  it('should display resource name as chart title', () => {
+    const quota = createMockQuota({ pods: '10' }, { pods: '5' });
+
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(screen.getByRole('group', { name: 'Cluster resource quota: pods' })).toHaveTextContent(
+      'pods',
+    );
+  });
+
+  it('should display usage label on chart', () => {
+    const quota = createMockQuota({ pods: '10' }, { pods: '5' });
+
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(screen.getByRole('group', { name: 'Cluster resource quota: pods' })).toHaveTextContent(
+      '5 of 10',
+    );
+  });
+
+  it('should render multiple charts for different resource types', () => {
+    const quota = createMockQuota(
+      {
+        'limits.cpu': '4',
+        'limits.memory': '8Gi',
+        pods: '20',
+      },
+      {
+        'limits.cpu': '2',
+        'limits.memory': '4Gi',
+        pods: '10',
+      },
+    );
+
+    render(<ClusterResourceQuotaCharts clusterResourceQuota={quota} />);
+
+    expect(
+      screen.getByRole('group', { name: 'Cluster resource quota: limits.cpu' }),
+    ).toHaveTextContent('limits.cpu');
+    expect(
+      screen.getByRole('group', { name: 'Cluster resource quota: limits.memory' }),
+    ).toHaveTextContent('limits.memory');
+    expect(screen.getByRole('group', { name: 'Cluster resource quota: pods' })).toHaveTextContent(
+      'pods',
+    );
+  });
+});
diff --git a/frontend/packages/console-app/src/components/resource-quota/__tests__/ResourceQuotaCharts.spec.tsx b/frontend/packages/console-app/src/components/resource-quota/__tests__/ResourceQuotaCharts.spec.tsx
new file mode 100644
index 00000000000..12316326b52
--- /dev/null
+++ b/frontend/packages/console-app/src/components/resource-quota/__tests__/ResourceQuotaCharts.spec.tsx
@@ -0,0 +1,111 @@
+import { render, screen } from '@testing-library/react';
+import type { ResourceQuotaKind } from '@console/internal/module/k8s';
+import ResourceQuotaCharts from '../ResourceQuotaCharts';
+
+jest.mock('@console/internal/components/graphs/gauge', () => ({
+  GaugeChart: ({ title, label }: { title: string; label: string }) => (
+    <div role="group" aria-label={`Resource quota: ${title}`}>
+      <span>{title}</span>
+      <span>{label}</span>
+    </div>
+  ),
+}));
+
+jest.mock('../utils', () => ({
+  getLabelAndUsage: jest.fn(({ used, hard }: { used: string; hard: string }) => ({
+    label: `${used || 0} of ${hard}`,
+    percent: hard ? (parseInt(used || '0', 10) / parseInt(hard, 10)) * 100 : 0,
+  })),
+}));
+
+describe('ResourceQuotaCharts', () => {
+  const createMockQuota = (
+    hardResources: Record<string, string> = {},
+    usedResources: Record<string, string> = {},
+  ): ResourceQuotaKind =>
+    ({
+      apiVersion: 'v1',
+      kind: 'ResourceQuota',
+      metadata: {
+        name: 'test-quota',
+        namespace: 'default',
+      },
+      status: {
+        hard: hardResources,
+        used: usedResources,
+      },
+    } as ResourceQuotaKind);
+
+  it('should display "No quota" when no hard quotas are set', () => {
+    const quota = createMockQuota({}, {});
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getByText('No quota')).toBeVisible();
+  });
+
+  it('should display "No quota" when status is undefined', () => {
+    const quota: ResourceQuotaKind = {
+      apiVersion: 'v1',
+      kind: 'ResourceQuota',
+      metadata: {
+        name: 'test-quota',
+        namespace: 'default',
+      },
+    } as ResourceQuotaKind;
+
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getByText('No quota')).toBeVisible();
+  });
+
+  it('should render gauge chart for each resource', () => {
+    const quota = createMockQuota({ pods: '10', secrets: '20' }, { pods: '5', secrets: '10' });
+
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getAllByRole('group', { name: /Resource quota:/ })).toHaveLength(2);
+  });
+
+  it('should display resource name as chart title', () => {
+    const quota = createMockQuota({ pods: '10' }, { pods: '5' });
+
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getByRole('group', { name: 'Resource quota: pods' })).toHaveTextContent('pods');
+  });
+
+  it('should display usage label on chart', () => {
+    const quota = createMockQuota({ pods: '10' }, { pods: '5' });
+
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getByRole('group', { name: 'Resource quota: pods' })).toHaveTextContent(
+      '5 of 10',
+    );
+  });
+
+  it('should render multiple charts for different resource types', () => {
+    const quota = createMockQuota(
+      {
+        'limits.cpu': '4',
+        'limits.memory': '8Gi',
+        pods: '20',
+      },
+      {
+        'limits.cpu': '2',
+        'limits.memory': '4Gi',
+        pods: '10',
+      },
+    );
+
+    render(<ResourceQuotaCharts resourceQuota={quota} />);
+
+    expect(screen.getByRole('group', { name: 'Resource quota: limits.cpu' })).toHaveTextContent(
+      'limits.cpu',
+    );
+    expect(screen.getByRole('group', { name: 'Resource quota: limits.memory' })).toHaveTextContent(
+      'limits.memory',
+    );
+    expect(screen.getByRole('group', { name: 'Resource quota: pods' })).toHaveTextContent('pods');
+  });
+});
diff --git a/frontend/packages/console-app/src/components/resource-quota/__tests__/utils.spec.ts b/frontend/packages/console-app/src/components/resource-quota/__tests__/utils.spec.ts
new file mode 100644
index 00000000000..460494acbcc
--- /dev/null
+++ b/frontend/packages/console-app/src/components/resource-quota/__tests__/utils.spec.ts
@@ -0,0 +1,124 @@
+import { getUsedPercentage, getLabelAndUsage } from '../utils';
+
+jest.mock('@console/internal/components/utils/units', () => ({
+  convertToBaseValue: jest.fn((val: string) => {
+    // Handle common unit suffixes
+    if (val.endsWith('Gi')) {
+      return parseFloat(val) * 1024 * 1024 * 1024;
+    }
+    if (val.endsWith('Mi')) {
+      return parseFloat(val) * 1024 * 1024;
+    }
+    if (val.endsWith('Ki')) {
+      return parseFloat(val) * 1024;
+    }
+    if (val.endsWith('m')) {
+      return parseFloat(val) / 1000;
+    }
+    // Return null for plain numbers to trigger parseInt fallback
+    const num = parseFloat(val);
+    return Number.isNaN(num) ? null : num;
+  }),
+  humanizePercentage: jest.fn((percent: number) => ({
+    string: `${percent.toFixed(0)}%`,
+  })),
+}));
+
+describe('utils', () => {
+  describe('getUsedPercentage', () => {
+    it('should return 0 when hard is undefined', () => {
+      expect(getUsedPercentage(undefined, '10')).toBe(0);
+    });
+
+    it('should return 0 when used is undefined', () => {
+      expect(getUsedPercentage('100', undefined)).toBe(0);
+    });
+
+    it('should return 0 when both values are undefined', () => {
+      expect(getUsedPercentage(undefined, undefined)).toBe(0);
+    });
+
+    it('should calculate percentage for plain numbers', () => {
+      const result = getUsedPercentage('100', '50');
+      expect(result).toBe(50);
+    });
+
+    it('should calculate percentage for values with units', () => {
+      const result = getUsedPercentage('2Gi', '1Gi');
+      expect(result).toBe(50);
+    });
+
+    it('should return 0 when calculated values are invalid', () => {
+      const result = getUsedPercentage('invalid', 'invalid');
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('getLabelAndUsage', () => {
+    it('should return count format for count/ prefixed resources', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'count/deployments.apps',
+        used: '5',
+        hard: '10',
+      });
+
+      expect(result.label).toBe('5 of 10');
+      expect(result.percent).toBe(50);
+    });
+
+    it('should return count format for pods (generic count resource)', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'pods',
+        used: '3',
+        hard: '10',
+      });
+
+      expect(result.label).toBe('3 of 10');
+      expect(result.percent).toBe(30);
+    });
+
+    it('should return count format for secrets (generic count resource)', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'secrets',
+        used: '8',
+        hard: '20',
+      });
+
+      expect(result.label).toBe('8 of 20');
+      expect(result.percent).toBe(40);
+    });
+
+    it('should return percentage format for memory resources', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'limits.memory',
+        used: '1Gi',
+        hard: '2Gi',
+      });
+
+      expect(result.label).toBe('50%');
+      expect(result.percent).toBe(50);
+    });
+
+    it('should return percentage format for cpu resources', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'limits.cpu',
+        used: '500m',
+        hard: '1000m',
+      });
+
+      expect(result.label).toBe('50%');
+      expect(result.percent).toBe(50);
+    });
+
+    it('should handle missing used value with 0', () => {
+      const result = getLabelAndUsage({
+        resourceName: 'pods',
+        used: '',
+        hard: '10',
+      });
+
+      expect(result.label).toBe('0 of 10');
+      expect(result.percent).toBe(0);
+    });
+  });
+});
diff --git a/frontend/packages/console-app/src/components/volume-modes/__tests__/volume-mode.spec.tsx b/frontend/packages/console-app/src/components/volume-modes/__tests__/volume-mode.spec.tsx
new file mode 100644
index 00000000000..f3d9bc2edae
--- /dev/null
+++ b/frontend/packages/console-app/src/components/volume-modes/__tests__/volume-mode.spec.tsx
@@ -0,0 +1,97 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { PersistentVolumeClaimKind } from '@console/internal/module/k8s';
+import { VolumeModeSelector } from '../volume-mode';
+
+jest.mock('@console/internal/components/storage/shared', () => ({
+  getVolumeModeRadios: () => [
+    { value: 'Filesystem', label: 'Filesystem' },
+    { value: 'Block', label: 'Block' },
+  ],
+  getVolumeModeForProvisioner: jest.fn(() => ['Filesystem', 'Block']),
+  initialVolumeModes: ['Filesystem', 'Block'],
+}));
+
+jest.mock('@console/internal/components/utils/field-level-help', () => ({
+  FieldLevelHelp: ({ children }: { children: React.ReactNode }) => (
+    <aside aria-label="Field help">{children}</aside>
+  ),
+}));
+
+describe('VolumeModeSelector', () => {
+  const defaultProps = {
+    onChange: jest.fn(),
+    loaded: true,
+    provisioner: 'kubernetes.io/aws-ebs',
+    storageClass: 'gp2',
+    accessMode: 'ReadWriteOnce',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should render volume mode label', () => {
+    render(<VolumeModeSelector {...defaultProps} />);
+
+    expect(screen.getByText('Volume mode')).toBeVisible();
+  });
+
+  it('should render radio buttons when multiple volume modes are allowed', () => {
+    render(<VolumeModeSelector {...defaultProps} />);
+
+    expect(screen.getByRole('radio', { name: 'Filesystem' })).toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: 'Block' })).toBeInTheDocument();
+  });
+
+  it('should call onChange when volume mode is selected', async () => {
+    const user = userEvent.setup();
+    const onChange = jest.fn();
+    render(<VolumeModeSelector {...defaultProps} onChange={onChange} />);
+
+    const blockRadio = screen.getByRole('radio', { name: 'Block' });
+    await user.click(blockRadio);
+
+    expect(onChange).toHaveBeenCalledWith('Block');
+  });
+
+  it('should show initial volume mode from PVC resource', () => {
+    const mockPVC = {
+      apiVersion: 'v1',
+      kind: 'PersistentVolumeClaim',
+      metadata: { name: 'test-pvc', namespace: 'default' },
+      spec: {
+        accessModes: ['ReadWriteOnce'],
+        resources: { requests: { storage: '1Gi' } },
+        storageClassName: 'gp2',
+        volumeMode: 'Block',
+      },
+    } as PersistentVolumeClaimKind;
+
+    render(<VolumeModeSelector {...defaultProps} pvcResource={mockPVC} />);
+
+    const blockRadio = screen.getByRole('radio', { name: 'Block' });
+    expect(blockRadio).toBeInTheDocument();
+  });
+
+  it('should use available volume mode when provided', () => {
+    render(<VolumeModeSelector {...defaultProps} availableVolumeMode="Block" />);
+
+    expect(screen.getByRole('radio', { name: 'Block' })).toBeInTheDocument();
+  });
+
+  it('should render as radiogroup for accessibility', () => {
+    render(<VolumeModeSelector {...defaultProps} />);
+
+    expect(screen.getByRole('radiogroup')).toBeInTheDocument();
+  });
+
+  it('should remain interactive when className is provided', async () => {
+    const user = userEvent.setup();
+    const onChange = jest.fn();
+    render(<VolumeModeSelector {...defaultProps} className="custom-class" onChange={onChange} />);
+
+    await user.click(screen.getByRole('radio', { name: 'Block' }));
+    expect(onChange).toHaveBeenCalledWith('Block');
+  });
+});
diff --git a/frontend/packages/console-shared/locales/en/console-shared.json b/frontend/packages/console-shared/locales/en/console-shared.json
index 01ed4c5bd31..47dc4905b1c 100644
--- a/frontend/packages/console-shared/locales/en/console-shared.json
+++ b/frontend/packages/console-shared/locales/en/console-shared.json
@@ -27,6 +27,7 @@
   "Documentation": "Documentation",
   "Get support": "Get support",
   "Refer documentation": "Refer documentation",
+  "Form layout": "Form layout",
   "Could not load configuration.": "Could not load configuration.",
   "Saved.": "Saved.",
   "This config update requires a console rollout, this can take up to a minute and require a browser refresh.": "This config update requires a console rollout, this can take up to a minute and require a browser refresh.",
@@ -134,6 +135,7 @@
   "Something wrong happened": "Something wrong happened",
   "An error occurred. Please try again.": "An error occurred. Please try again.",
   "Reload page": "Reload page",
+  "Inline error boundary": "Inline error boundary",
   "You made changes to this page.": "You made changes to this page.",
   "Click {{submit}} to save changes or {{reset}} to cancel changes.": "Click {{submit}} to save changes or {{reset}} to cancel changes.",
   "Reload": "Reload",
diff --git a/frontend/packages/console-shared/src/components/cluster-configuration/FormLayout.tsx b/frontend/packages/console-shared/src/components/cluster-configuration/FormLayout.tsx
index 0ec4fe48477..6b51e71588c 100644
--- a/frontend/packages/console-shared/src/components/cluster-configuration/FormLayout.tsx
+++ b/frontend/packages/console-shared/src/components/cluster-configuration/FormLayout.tsx
@@ -2,6 +2,7 @@ import type { FC } from 'react';
 import type { FormProps } from '@patternfly/react-core';
 import { css } from '@patternfly/react-styles';
 import formStyles from '@patternfly/react-styles/css/components/Form/form';
+import { useTranslation } from 'react-i18next';
 
 export type FormLayoutProps = Pick<FormProps, 'children' | 'isHorizontal' | 'isWidthLimited'>;
 
@@ -10,8 +11,11 @@ const FormLayout: FC<FormLayoutProps> = ({
   isHorizontal = false,
   isWidthLimited = true,
 }) => {
+  const { t } = useTranslation();
   return (
     <div
+      role="region"
+      aria-label={t('console-shared~Form layout')}
       className={css(
         formStyles.form,
         isHorizontal && formStyles.modifiers.horizontal,
diff --git a/frontend/packages/console-shared/src/components/error/fallbacks/ErrorBoundaryInline.tsx b/frontend/packages/console-shared/src/components/error/fallbacks/ErrorBoundaryInline.tsx
index d6ef3a20100..138675a003a 100644
--- a/frontend/packages/console-shared/src/components/error/fallbacks/ErrorBoundaryInline.tsx
+++ b/frontend/packages/console-shared/src/components/error/fallbacks/ErrorBoundaryInline.tsx
@@ -1,4 +1,5 @@
 import type { ReactNode, ComponentType, FC } from 'react';
+import { useTranslation } from 'react-i18next';
 import ErrorBoundary from '../error-boundary';
 import ErrorBoundaryFallbackInline from './ErrorBoundaryFallbackInline';
 
@@ -16,6 +17,7 @@ const ErrorBoundaryInline: FC<ErrorBoundaryInlineProps> = ({
   children,
   ...props
 }) => {
+  const { t } = useTranslation('console-shared');
   let fallback = ErrorBoundaryFallbackInline;
   if (Wrapper) {
     fallback = (innerProps) => (
@@ -26,9 +28,11 @@ const ErrorBoundaryInline: FC<ErrorBoundaryInlineProps> = ({
   }
 
   return (
-    <ErrorBoundary {...props} FallbackComponent={fallback}>
-      {children}
-    </ErrorBoundary>
+    <div role="region" aria-label={t('Inline error boundary')}>
+      <ErrorBoundary {...props} FallbackComponent={fallback}>
+        {children}
+      </ErrorBoundary>
+    </div>
   );
 };