diff --git a/frontend/__tests__/mockData/mockSnapshotData.ts b/frontend/__tests__/mockData/mockSnapshotData.ts
index 39fe8bf1b7..7425bb08fa 100644
--- a/frontend/__tests__/mockData/mockSnapshotData.ts
+++ b/frontend/__tests__/mockData/mockSnapshotData.ts
@@ -10,6 +10,7 @@ export const mockSnapshotDetailsData = {
     errorMessage: '',
     newReleases: [
       {
+        id: 'release-1',
         name: 'v0.9.2',
         publishedAt: '2024-12-13T14:43:46+00:00',
         tagName: 'v0.9.2',
@@ -24,6 +25,7 @@ export const mockSnapshotDetailsData = {
         },
       },
       {
+        id: 'release-2',
         name: 'Latest pre-release',
         publishedAt: '2024-12-13T13:17:30+00:00',
         tagName: 'pre-release',
diff --git a/frontend/__tests__/unit/components/Footer.test.tsx b/frontend/__tests__/unit/components/Footer.test.tsx
index 6a9bd10f01..e28c1fc80b 100644
--- a/frontend/__tests__/unit/components/Footer.test.tsx
+++ b/frontend/__tests__/unit/components/Footer.test.tsx
@@ -46,6 +46,7 @@ jest.mock('utils/constants', () => ({
       links: [
         { text: 'About', href: '/about' },
         { text: 'Contribute', href: 'https://github.com/OWASP/Nest/blob/main/CONTRIBUTING.md' },
+        { text: 'Empty Href Link', href: '' }, // Empty href to test fallback
       ],
     },
     {
@@ -71,9 +72,18 @@ jest.mock('utils/constants', () => ({
   ],
 }))
 
-jest.mock('utils/env.client', () => ({
+let mockEnv = {
   ENVIRONMENT: 'production',
   RELEASE_VERSION: '1.2.3',
+}
+
+jest.mock('utils/env.client', () => ({
+  get ENVIRONMENT() {
+    return mockEnv.ENVIRONMENT
+  },
+  get RELEASE_VERSION() {
+    return mockEnv.RELEASE_VERSION
+  },
 }))
 
 import { FaGithub, FaSlack } from 'react-icons/fa6'
@@ -93,6 +103,10 @@ describe('Footer', () => {
 
   beforeEach(() => {
     jest.clearAllMocks()
+    mockEnv = {
+      ENVIRONMENT: 'production',
+      RELEASE_VERSION: '1.2.3',
+    }
   })
 
   afterEach(() => {
@@ -132,10 +146,12 @@ describe('Footer', () => {
           }
         }
       }
+
       for (const link of regularLinks) {
         const linkElement = screen.getByRole('link', { name: link.text })
         expect(linkElement).toBeInTheDocument()
-        expect(linkElement).toHaveAttribute('href', link.href)
+        const expectedHref = link.href || '/'
+        expect(linkElement).toHaveAttribute('href', expectedHref)
         expect(linkElement).toHaveAttribute('target', '_blank')
       }
 
@@ -266,63 +282,29 @@ describe('Footer', () => {
       expect(versionLink).toHaveAttribute('rel', 'noopener noreferrer')
     })
 
-    test('handles span elements correctly', () => {
-      renderFooter()
-
-      const spanText = screen.getByText('Plain Text')
-      expect(spanText.tagName).toBe('SPAN')
-      expect(spanText).toHaveClass('text-slate-600', 'dark:text-slate-400')
-    })
-  })
-
-  describe('Version Link Behavior', () => {
-    let originalEnvironment: string
-    let originalReleaseVersion: string
-    let envModule: typeof import('utils/env.client')
-
-    beforeEach(() => {
-      jest.clearAllMocks()
-      envModule = jest.requireMock<typeof import('utils/env.client')>('utils/env.client')
-      originalEnvironment = envModule.ENVIRONMENT
-      originalReleaseVersion = envModule.RELEASE_VERSION
-    })
-
-    afterEach(() => {
-      if (envModule) {
-        envModule.ENVIRONMENT = originalEnvironment
-        envModule.RELEASE_VERSION = originalReleaseVersion
-      }
-    })
-
-    test('renders version as commit link in staging environment', () => {
-      envModule.ENVIRONMENT = 'staging'
-      envModule.RELEASE_VERSION = '24.2.10-12c25c5'
+    test('renders version as commit link in non-production environment', () => {
+      mockEnv.ENVIRONMENT = 'staging'
+      mockEnv.RELEASE_VERSION = '24.2.10-12c25c5'
 
-      const { container } = render(<Footer />)
-      const versionLink = container.querySelector('a[href*="commit"]')
+      renderFooter()
 
+      const versionText = screen.getByText('v24.2.10-12c25c5')
+      const versionLink = versionText.closest('a')
       expect(versionLink).toBeInTheDocument()
       expect(versionLink).toHaveAttribute('href', 'https://github.com/OWASP/Nest/commit/12c25c5')
       expect(versionLink).toHaveAttribute('target', '_blank')
       expect(versionLink).toHaveAttribute('rel', 'noopener noreferrer')
-      expect(versionLink).toHaveTextContent('v24.2.10-12c25c5')
-    })
 
-    test('renders version as release tag link in production environment', () => {
-      envModule.ENVIRONMENT = 'production'
-      envModule.RELEASE_VERSION = '1.2.3'
+      mockEnv.ENVIRONMENT = 'production'
+      mockEnv.RELEASE_VERSION = '1.2.3'
+    })
 
-      const { container } = render(<Footer />)
-      const versionLink = container.querySelector('a[href*="releases"]')
+    test('handles span elements correctly', () => {
+      renderFooter()
 
-      expect(versionLink).toBeInTheDocument()
-      expect(versionLink).toHaveAttribute(
-        'href',
-        'https://github.com/OWASP/Nest/releases/tag/1.2.3'
-      )
-      expect(versionLink).toHaveAttribute('target', '_blank')
-      expect(versionLink).toHaveAttribute('rel', 'noopener noreferrer')
-      expect(versionLink).toHaveTextContent('v1.2.3')
+      const spanText = screen.getByText('Plain Text')
+      expect(spanText.tagName).toBe('SPAN')
+      expect(spanText).toHaveClass('text-slate-600', 'dark:text-slate-400')
     })
   })
 
@@ -420,6 +402,13 @@ describe('Footer', () => {
       expect(aboutLink).toHaveAttribute('href', '/about')
     })
 
+    test('handles empty href with fallback to root path', () => {
+      renderFooter()
+
+      const emptyHrefLink = screen.getByRole('link', { name: 'Empty Href Link' })
+      expect(emptyHrefLink).toHaveAttribute('href', '/')
+    })
+
     test('handles sections with span elements', () => {
       renderFooter()
 
diff --git a/frontend/__tests__/unit/components/HealthMetrics.test.tsx b/frontend/__tests__/unit/components/HealthMetrics.test.tsx
index d33c50e78d..cedba94af4 100644
--- a/frontend/__tests__/unit/components/HealthMetrics.test.tsx
+++ b/frontend/__tests__/unit/components/HealthMetrics.test.tsx
@@ -135,5 +135,43 @@ describe('HealthMetrics', () => {
       expect(props.days).toEqual([0, 0])
       expect(props.requirements).toEqual([0, 0])
     })
+
+    it('handles completely null/undefined optional fields', () => {
+      const nullData = [
+        {
+          createdAt: null,
+          openIssuesCount: null,
+          unassignedIssuesCount: undefined,
+          unansweredIssuesCount: null,
+          openPullRequestsCount: undefined,
+          starsCount: null,
+          forksCount: undefined,
+          id: 'null-test',
+          projectKey: 'null-project',
+        },
+      ]
+      // @ts-expect-error - testing specific edge case with mocked data
+      render(<HealthMetrics data={nullData} />)
+
+      const lineCharts = screen.getAllByTestId('LineChart')
+
+      const issuesProps = JSON.parse(lineCharts[0].dataset.props || '{}')
+      expect(issuesProps.series[0].data).toEqual([0]) // openIssuesCount
+      expect(issuesProps.series[1].data).toEqual([0]) // unassignedIssuesCount
+      expect(issuesProps.series[2].data).toEqual([0]) // unansweredIssuesCount
+      expect(issuesProps.labels).toEqual(['']) // createdAt
+
+      // Pull Requests Trend
+      const prProps = JSON.parse(lineCharts[1].dataset.props || '{}')
+      expect(prProps.series[0].data).toEqual([0])
+
+      // Stars Trend
+      const starsProps = JSON.parse(lineCharts[2].dataset.props || '{}')
+      expect(starsProps.series[0].data).toEqual([0])
+
+      // Forks Trend
+      const forksProps = JSON.parse(lineCharts[3].dataset.props || '{}')
+      expect(forksProps.series[0].data).toEqual([0])
+    })
   })
 })
diff --git a/frontend/__tests__/unit/components/IssuesTable.test.tsx b/frontend/__tests__/unit/components/IssuesTable.test.tsx
index f4c754a3c0..d998b47748 100644
--- a/frontend/__tests__/unit/components/IssuesTable.test.tsx
+++ b/frontend/__tests__/unit/components/IssuesTable.test.tsx
@@ -4,9 +4,11 @@ import React from 'react'
 import IssuesTable, { type IssueRow } from 'components/IssuesTable'
 import { LabelList } from 'components/LabelList'
 
+const mockPush = jest.fn()
+
 jest.mock('next/navigation', () => ({
   useRouter: () => ({
-    push: jest.fn(),
+    push: mockPush,
   }),
 }))
 
@@ -367,6 +369,26 @@ describe('<IssuesTable />', () => {
       const user4Texts = screen.getAllByText('user4')
       expect(user4Texts.length).toBeGreaterThan(0)
     })
+
+    it('uses name when login is not available', () => {
+      const issueWithoutLogin: IssueRow = {
+        objectID: '8-no-login',
+        number: 133,
+        title: 'Issue Without Login',
+        state: 'open',
+        labels: [],
+        assignees: [
+          {
+            avatarUrl: 'https://example.com/avatar5.jpg',
+            login: '',
+            name: 'User Five',
+          },
+        ],
+      }
+      render(<IssuesTable issues={[issueWithoutLogin]} />)
+      const user5Texts = screen.getAllByText('User Five')
+      expect(user5Texts.length).toBeGreaterThan(0)
+    })
   })
 
   describe('Click Handlers', () => {
@@ -378,6 +400,24 @@ describe('<IssuesTable />', () => {
       fireEvent.click(issueButtons[0])
       expect(onIssueClick).toHaveBeenCalledWith(123)
     })
+
+    it('navigates to issue URL when onIssueClick is not provided', () => {
+      const issueUrl = (num: number) => `/issues/${num}`
+      render(<IssuesTable {...defaultProps} onIssueClick={undefined} issueUrl={issueUrl} />)
+      const issueButtons = screen.getAllByRole('button', { name: /Test Issue 1/i })
+      expect(issueButtons.length).toBeGreaterThan(0)
+      fireEvent.click(issueButtons[0])
+      expect(mockPush).toHaveBeenCalledWith('/issues/123')
+    })
+
+    it('does nothing when onIssueClick and issueUrl are not provided', () => {
+      mockPush.mockClear()
+      render(<IssuesTable {...defaultProps} onIssueClick={undefined} issueUrl={undefined} />)
+      const issueButtons = screen.getAllByRole('button', { name: /Test Issue 1/i })
+      expect(issueButtons.length).toBeGreaterThan(0)
+      fireEvent.click(issueButtons[0])
+      expect(mockPush).not.toHaveBeenCalled()
+    })
   })
 
   describe('Empty State', () => {
diff --git a/frontend/__tests__/unit/components/LabelList.test.tsx b/frontend/__tests__/unit/components/LabelList.test.tsx
new file mode 100644
index 0000000000..07384103d1
--- /dev/null
+++ b/frontend/__tests__/unit/components/LabelList.test.tsx
@@ -0,0 +1,43 @@
+import { render, screen } from '@testing-library/react'
+import '@testing-library/jest-dom'
+import { LabelList } from 'components/LabelList'
+
+describe('LabelList', () => {
+  it('renders nothing when labels are empty', () => {
+    const { container } = render(<LabelList entityKey="test-1" labels={[]} />)
+    expect(container).toBeEmptyDOMElement()
+  })
+
+  it('renders nothing when labels are undefined', () => {
+    const { container } = render(<LabelList entityKey="test-2" labels={undefined} />)
+    expect(container).toBeEmptyDOMElement()
+  })
+
+  it('renders labels correctly', () => {
+    render(<LabelList entityKey="test-3" labels={['label1', 'label2']} />)
+    expect(screen.getByText('label1')).toBeInTheDocument()
+    expect(screen.getByText('label2')).toBeInTheDocument()
+  })
+
+  it('renders max visible labels and remaining count', () => {
+    render(<LabelList entityKey="test-4" labels={['1', '2', '3', '4', '5', '6']} maxVisible={5} />)
+    expect(screen.getByText('1')).toBeInTheDocument()
+    expect(screen.getByText('5')).toBeInTheDocument()
+    expect(screen.queryByText('6')).not.toBeInTheDocument()
+    expect(screen.getByText('+1 more')).toBeInTheDocument()
+  })
+
+  it('applies custom className', () => {
+    const { container } = render(
+      <LabelList entityKey="test-5" labels={['label']} className="custom-class" />
+    )
+    expect(container.firstChild).toHaveClass('custom-class')
+  })
+
+  it('renders all labels when maxVisible is greater than labels length', () => {
+    render(<LabelList entityKey="test-6" labels={['1', '2']} maxVisible={5} />)
+    expect(screen.getByText('1')).toBeInTheDocument()
+    expect(screen.getByText('2')).toBeInTheDocument()
+    expect(screen.queryByText(/\+\d+ more/)).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/__tests__/unit/components/LogoCarousel.test.tsx b/frontend/__tests__/unit/components/LogoCarousel.test.tsx
index 496dd0d1ed..3fa1bb4a55 100644
--- a/frontend/__tests__/unit/components/LogoCarousel.test.tsx
+++ b/frontend/__tests__/unit/components/LogoCarousel.test.tsx
@@ -443,6 +443,56 @@ describe('MovingLogos (LogoCarousel)', () => {
     })
   })
 
+  describe('Coverage Edge Cases', () => {
+    it('uses url for key generation when id is missing', () => {
+      const sponsor: Sponsor = {
+        id: undefined as unknown as string,
+        name: 'Name',
+        imageUrl: 'https://img.com',
+        url: 'https://url.com',
+        sponsorType: 'Gold',
+      }
+      render(<MovingLogos sponsors={[sponsor]} />)
+      expect(screen.getAllByTestId('sponsor-link')).toHaveLength(4)
+    })
+
+    it('uses name for key generation when id and url are missing', () => {
+      const sponsor: Sponsor = {
+        id: undefined as unknown as string,
+        name: 'Name',
+        imageUrl: 'https://img.com',
+        url: '',
+        sponsorType: 'Gold',
+      }
+      render(<MovingLogos sponsors={[sponsor]} />)
+      expect(screen.getAllByTestId('sponsor-link')).toHaveLength(4)
+    })
+
+    it('uses generic fallback for key generation when id, url, and name are missing', () => {
+      const sponsor: Sponsor = {
+        id: undefined as unknown as string,
+        name: '',
+        imageUrl: 'https://img.com',
+        url: '',
+        sponsorType: 'Gold',
+      }
+      render(<MovingLogos sponsors={[sponsor]} />)
+      expect(screen.getAllByTestId('sponsor-link')).toHaveLength(4)
+    })
+
+    it('renders generic "Sponsor" text when name and image are missing', () => {
+      const sponsor: Sponsor = {
+        id: '1',
+        name: '',
+        imageUrl: '',
+        url: 'https://url.com',
+        sponsorType: 'Gold',
+      }
+      render(<MovingLogos sponsors={[sponsor]} />)
+      expect(screen.getAllByText('Sponsor')).toHaveLength(2)
+    })
+  })
+
   describe('Accessibility Roles and Labels', () => {
     it('provides proper alt text for images', () => {
       render(<MovingLogos sponsors={mockSponsors} />)
diff --git a/frontend/__tests__/unit/components/MetricsCard.test.tsx b/frontend/__tests__/unit/components/MetricsCard.test.tsx
index 7ea113a9da..fc06a5327f 100644
--- a/frontend/__tests__/unit/components/MetricsCard.test.tsx
+++ b/frontend/__tests__/unit/components/MetricsCard.test.tsx
@@ -99,4 +99,18 @@ describe('MetricsCard component', () => {
     expect(screen.getByText(/Score:/).textContent).toContain('55')
     expect(screen.getByRole('link')).toHaveAttribute('href', '/projects/dashboard/metrics/another')
   })
+
+  it('handles undefined optional props using defaults', () => {
+    const metric = makeMetric({
+      score: undefined,
+      createdAt: undefined,
+    })
+    render(<MetricsCard metric={metric} />)
+
+    const scoreText = screen.getByText(/Score: 0/)
+    expect(scoreText).toBeInTheDocument()
+    expect(scoreText.closest('div')).toHaveClass('bg-red-500')
+
+    expect(screen.getByText('N/A')).toBeInTheDocument()
+  })
 })
diff --git a/frontend/__tests__/unit/components/MultiSearch.test.tsx b/frontend/__tests__/unit/components/MultiSearch.test.tsx
index bd4293269e..a349a08065 100644
--- a/frontend/__tests__/unit/components/MultiSearch.test.tsx
+++ b/frontend/__tests__/unit/components/MultiSearch.test.tsx
@@ -1,5 +1,5 @@
 import { sendGAEvent } from '@next/third-parties/google'
-import { screen, render, waitFor } from '@testing-library/react'
+import { screen, render, waitFor, fireEvent } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { useRouter } from 'next/navigation'
 import React from 'react'
@@ -541,6 +541,132 @@ describe('Rendering', () => {
 
         expect(mockPush).toHaveBeenCalledWith('/chapters/test-chapter')
       })
+
+      it('moves highlight to next category on ArrowDown from last item', async () => {
+        const user = userEvent.setup()
+        render(<MultiSearchBar {...defaultProps} />)
+
+        const input = screen.getByPlaceholderText('Search...')
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        // Mock returns 2 hits per index. Indexes: chapters, users, projects.
+        // Index 0 (chapters), Hit 0
+        await user.keyboard('{ArrowDown}')
+        // Index 0, Hit 1 (Last of chapters)
+        await user.keyboard('{ArrowDown}')
+        // Should move to Index 1 (users), Hit 0
+        await user.keyboard('{ArrowDown}')
+
+        const listItems = screen.getAllByRole('listitem')
+        // Total items: 2 chapters + 2 users + 2 projects = 6 items.
+        // Index 0 (ch0), 1 (ch1), 2 (u0).
+        expect(listItems[2]).toHaveClass('bg-gray-100')
+      })
+
+      it('moves highlight to previous category last item on ArrowUp from first item', async () => {
+        const user = userEvent.setup()
+        render(<MultiSearchBar {...defaultProps} />)
+
+        const input = screen.getByPlaceholderText('Search...')
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        // Navigate to Index 1 (users), Hit 0
+        await user.keyboard('{ArrowDown}') // 0,0
+        await user.keyboard('{ArrowDown}') // 0,1
+        await user.keyboard('{ArrowDown}') // 1,0
+
+        // Now move UP
+        await user.keyboard('{ArrowUp}')
+
+        // Should be at Index 0 (chapters), Hit 1 (last item)
+        const listItems = screen.getAllByRole('listitem')
+        expect(listItems[1]).toHaveClass('bg-gray-100')
+      })
+
+      it('triggers click on suggestion button KeyDown (Enter/Space)', async () => {
+        const user = userEvent.setup()
+        render(<MultiSearchBar {...defaultProps} />)
+
+        const input = screen.getByPlaceholderText('Search...')
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        const suggestionBtns = screen.getAllByRole('button', { name: /Test Chapter/i })
+        const suggestionBtn = suggestionBtns[0]
+
+        // Test Enter key
+        suggestionBtn.focus()
+        await user.keyboard('{Enter}')
+        expect(mockPush).toHaveBeenCalledWith('/chapters/test-chapter')
+
+        // Reset mock and test Space key
+        mockPush.mockClear()
+
+        // Re-render suggestions
+        await user.clear(input)
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        const suggestionBtnsAfterRetype = screen.getAllByRole('button', { name: /Test Chapter/i })
+        const suggestionBtnForSpace = suggestionBtnsAfterRetype[0]
+
+        // Focus and trigger Space key using fireEvent for more direct control
+        suggestionBtnForSpace.focus()
+        fireEvent.keyDown(suggestionBtnForSpace, { key: ' ', code: 'Space' })
+
+        expect(mockPush).toHaveBeenCalledWith('/chapters/test-chapter')
+      })
+
+      it('does not move selection when pressing ArrowDown at the end of the list', async () => {
+        const user = userEvent.setup()
+        render(<MultiSearchBar {...defaultProps} />)
+
+        const input = screen.getByPlaceholderText('Search...')
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        // There are 3 categories (chapters, users, projects) with 2 items each. Total 6 items.
+        // Navigate to the last item.
+        for (let i = 0; i < 6; i++) {
+          await user.keyboard('{ArrowDown}')
+        }
+
+        const listItems = screen.getAllByRole('listitem')
+        // Verify last item is highlighted
+        expect(listItems[5]).toHaveClass('bg-gray-100')
+
+        // Press ArrowDown again
+        await user.keyboard('{ArrowDown}')
+
+        // Should still be at last item (no wrap, no crash)
+        expect(listItems[5]).toHaveClass('bg-gray-100')
+        expect(listItems[0]).not.toHaveClass('bg-gray-100')
+      })
+
+      it('does not move selection when pressing ArrowUp at the start of the list', async () => {
+        const user = userEvent.setup()
+        render(<MultiSearchBar {...defaultProps} />)
+
+        const input = screen.getByPlaceholderText('Search...')
+        await user.type(input, 'test')
+        await waitFor(expectListItemsExist)
+
+        // Navigate to first item
+        await user.keyboard('{ArrowDown}')
+        const listItems = screen.getAllByRole('listitem')
+        expect(listItems[0]).toHaveClass('bg-gray-100')
+
+        // Press ArrowUp
+        await user.keyboard('{ArrowUp}')
+
+        // Should still be at first item (or index null if logic allows, but here check it doesn't crash or go weird)
+        // Actually MultiSearch logic: if index>0 OR subIndex>0 decrement.
+        // If index=0 and subIndex=0, nothing happens in the `if/else if`.
+        // So state remains { index: 0, subIndex: 0 }
+        expect(listItems[0]).toHaveClass('bg-gray-100')
+      })
     })
   })
   describe('Navigation Handling', () => {
diff --git a/frontend/__tests__/unit/components/NavDropDown.test.tsx b/frontend/__tests__/unit/components/NavDropDown.test.tsx
index d6a401610b..2d10b722e7 100644
--- a/frontend/__tests__/unit/components/NavDropDown.test.tsx
+++ b/frontend/__tests__/unit/components/NavDropDown.test.tsx
@@ -294,6 +294,38 @@ describe('NavDropdown Component', () => {
       })
     })
 
+    it('closes dropdown when Escape is pressed on submenu item', async () => {
+      const user = userEvent.setup()
+      render(<NavDropdown {...defaultProps} />)
+
+      const button = screen.getByRole('button')
+      await user.click(button)
+
+      const submenuItem = screen.getByText('Getting Started')
+      submenuItem.focus()
+
+      await user.keyboard('{Escape}')
+      await waitFor(() => {
+        expect(screen.queryByText('Getting Started')).not.toBeInTheDocument()
+      })
+    })
+
+    it('closes dropdown when Space is pressed on submenu item', async () => {
+      const user = userEvent.setup()
+      render(<NavDropdown {...defaultProps} />)
+
+      const button = screen.getByRole('button')
+      await user.click(button)
+
+      const submenuItem = screen.getByText('Getting Started')
+      submenuItem.focus()
+
+      await user.keyboard(' ')
+      await waitFor(() => {
+        expect(screen.queryByText('Getting Started')).not.toBeInTheDocument()
+      })
+    })
+
     it('handles space key to toggle dropdown', async () => {
       const user = userEvent.setup()
       render(<NavDropdown {...defaultProps} />)
diff --git a/frontend/__tests__/unit/components/Pagination.test.tsx b/frontend/__tests__/unit/components/Pagination.test.tsx
index db26f6287b..b92b9e7af7 100644
--- a/frontend/__tests__/unit/components/Pagination.test.tsx
+++ b/frontend/__tests__/unit/components/Pagination.test.tsx
@@ -136,4 +136,23 @@ describe('<Pagination />', () => {
     renderComponent({ totalPages: 2, currentPage: 2 })
     expect(screen.getAllByRole('button', { name: /^Go to page [12]$/ })).toHaveLength(2)
   })
+  it('does not render trailing ellipsis when currentPage is near the end', () => {
+    renderComponent({ currentPage: 18, totalPages: 20 })
+
+    for (const n of [1, 2, 3]) {
+      expect(screen.getByRole('button', { name: `Go to page ${n}` })).toBeInTheDocument()
+    }
+
+    for (const n of [17, 18, 19]) {
+      expect(screen.getByRole('button', { name: `Go to page ${n}` })).toBeInTheDocument()
+    }
+
+    expect(screen.getByRole('button', { name: 'Go to page 20' })).toBeInTheDocument()
+
+    const ellipsisContainers = document.querySelectorAll('div.flex.h-10.w-10')
+    const ellipses = Array.from(ellipsisContainers).filter((el) =>
+      el.querySelector('svg[aria-hidden="true"]')
+    )
+    expect(ellipses).toHaveLength(1)
+  })
 })
diff --git a/frontend/__tests__/unit/components/ScrollToTop.test.tsx b/frontend/__tests__/unit/components/ScrollToTop.test.tsx
index 6ea09c2451..df05b06bef 100644
--- a/frontend/__tests__/unit/components/ScrollToTop.test.tsx
+++ b/frontend/__tests__/unit/components/ScrollToTop.test.tsx
@@ -1,4 +1,4 @@
-import { render, fireEvent, waitFor } from '@testing-library/react'
+import { render, fireEvent, waitFor, act } from '@testing-library/react'
 import ScrollToTop from 'components/ScrollToTop'
 
 describe('ScrollToTop component test', () => {
@@ -87,4 +87,30 @@ describe('ScrollToTop component test', () => {
     clearTimeoutSpy.mockRestore()
     jest.useRealTimers()
   })
+
+  test('Should throttle repeated scroll events', () => {
+    jest.useFakeTimers()
+    const setTimeoutSpy = jest.spyOn(globalThis, 'setTimeout')
+
+    render(<ScrollToTop />)
+
+    Object.defineProperty(globalThis, 'scrollY', { value: 400, writable: true })
+    globalThis.dispatchEvent(new Event('scroll'))
+
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1)
+
+    globalThis.dispatchEvent(new Event('scroll'))
+
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1) // Still 1
+
+    act(() => {
+      jest.advanceTimersByTime(100)
+    })
+
+    globalThis.dispatchEvent(new Event('scroll'))
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(2)
+
+    setTimeoutSpy.mockRestore()
+    jest.useRealTimers()
+  })
 })
diff --git a/frontend/__tests__/unit/components/SingleModuleCard.test.tsx b/frontend/__tests__/unit/components/SingleModuleCard.test.tsx
index a7b8876b40..a3b2cffa04 100644
--- a/frontend/__tests__/unit/components/SingleModuleCard.test.tsx
+++ b/frontend/__tests__/unit/components/SingleModuleCard.test.tsx
@@ -323,6 +323,44 @@ describe('SingleModuleCard', () => {
 
       expect(screen.getByText('No description available.')).toBeInTheDocument()
     })
+
+    it('renders contributor fallback details when name is missing', () => {
+      const moduleWithoutNames: Module = {
+        ...mockModule,
+        mentors: [
+          {
+            id: 'mentor-1',
+            name: '', // Empty name
+            login: 'mentor1',
+            avatarUrl: 'https://example.com/avatar.jpg',
+          },
+        ],
+      }
+      render(<SingleModuleCard module={moduleWithoutNames} />)
+
+      const avatar = screen.getByTestId('contributor-avatar')
+      expect(avatar).toHaveAttribute('alt', 'Mentors avatar')
+
+      expect(screen.getByText('Mentor1')).toBeInTheDocument() // upperFirst('mentor1')
+      const links = screen.getAllByRole('link')
+      const link = links.find((l) => l.getAttribute('href')?.includes('/members/mentor1'))
+      expect(link).toHaveAttribute('title', 'mentor1')
+    })
+
+    it('handles pathname without program key gracefully', () => {
+      mockUsePathname.mockReturnValue('/')
+      render(<SingleModuleCard module={mockModule} />)
+      expect(screen.getByText('Test Module')).toBeInTheDocument()
+    })
+
+    it('renders Unknown for missing detail values', () => {
+      const moduleWithEmptyDetails = {
+        ...mockModule,
+        experienceLevel: '' as unknown as ExperienceLevelEnum,
+      }
+      render(<SingleModuleCard module={moduleWithEmptyDetails} />)
+      expect(screen.getAllByText('Unknown').length).toBeGreaterThan(0)
+    })
   })
 
   describe('Accessibility', () => {
diff --git a/frontend/__tests__/unit/components/forms/shared/FormDateInput.test.tsx b/frontend/__tests__/unit/components/forms/shared/FormDateInput.test.tsx
new file mode 100644
index 0000000000..2aa5c59fe4
--- /dev/null
+++ b/frontend/__tests__/unit/components/forms/shared/FormDateInput.test.tsx
@@ -0,0 +1,166 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import { FormDateInput } from 'components/forms/shared/FormDateInput'
+
+jest.mock('components/forms/shared/FormDateInput', () => {
+  const originalModule = jest.requireActual('components/forms/shared/FormDateInput')
+  return {
+    ...originalModule,
+  }
+})
+
+jest.mock('@heroui/react', () => ({
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  Input: jest.fn(
+    ({
+      id,
+      label,
+      value,
+      onValueChange,
+      type,
+      isRequired,
+      isInvalid,
+      errorMessage,
+      min,
+      max,
+      labelPlacement,
+      classNames,
+    }) => (
+      <div data-testid="mock-input-container">
+        <label htmlFor={id}>{label}</label>
+        <input
+          id={id}
+          type={type}
+          value={value}
+          onChange={(e) => onValueChange(e.target.value)}
+          required={isRequired}
+          min={min}
+          max={max}
+          aria-invalid={isInvalid}
+          data-label-placement={labelPlacement}
+          data-class-names={JSON.stringify(classNames)}
+        />
+        {errorMessage && <span data-testid="error-message">{errorMessage}</span>}
+      </div>
+    )
+  ),
+}))
+
+describe('FormDateInput Component', () => {
+  const defaultProps = {
+    id: 'test-date',
+    label: 'Test Date',
+    value: '2024-01-01',
+    onValueChange: jest.fn(),
+  }
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('Rendering', () => {
+    it('renders with required props', () => {
+      render(<FormDateInput {...defaultProps} />)
+
+      expect(screen.getByLabelText('Test Date')).toBeInTheDocument()
+      expect(screen.getByLabelText('Test Date')).toHaveValue('2024-01-01')
+      expect(screen.getByLabelText('Test Date')).toHaveAttribute('type', 'date')
+    })
+
+    it('renders with required true', () => {
+      render(<FormDateInput {...defaultProps} required={true} />)
+
+      expect(screen.getByLabelText('Test Date')).toBeRequired()
+    })
+
+    it('renders with required false (explicit)', () => {
+      render(<FormDateInput {...defaultProps} required={false} />)
+
+      expect(screen.getByLabelText('Test Date')).not.toBeRequired()
+    })
+
+    it('renders with required undefined (default)', () => {
+      // This specifically targets the "required = false" default assignment
+      render(<FormDateInput {...defaultProps} required={undefined} />)
+
+      expect(screen.getByLabelText('Test Date')).not.toBeRequired()
+    })
+  })
+
+  describe('Validation', () => {
+    it('shows error message when touched and error exists', () => {
+      render(<FormDateInput {...defaultProps} touched={true} error="Invalid date" />)
+
+      expect(screen.getByTestId('error-message')).toHaveTextContent('Invalid date')
+      expect(screen.getByLabelText('Test Date')).toHaveAttribute('aria-invalid', 'true')
+    })
+
+    it('does not show error when not touched', () => {
+      render(<FormDateInput {...defaultProps} touched={false} error="Invalid date" />)
+
+      expect(screen.queryByTestId('error-message')).not.toBeInTheDocument()
+      expect(screen.getByLabelText('Test Date')).toHaveAttribute('aria-invalid', 'false')
+    })
+
+    it('does not show error when touched but no error', () => {
+      render(<FormDateInput {...defaultProps} touched={true} error="" />)
+
+      expect(screen.queryByTestId('error-message')).not.toBeInTheDocument()
+    })
+  })
+
+  describe('Interaction', () => {
+    it('calls onValueChange when input changes', () => {
+      render(<FormDateInput {...defaultProps} />)
+
+      const input = screen.getByLabelText('Test Date')
+      fireEvent.change(input, { target: { value: '2024-02-02' } })
+
+      expect(defaultProps.onValueChange).toHaveBeenCalledWith('2024-02-02')
+    })
+  })
+
+  describe('Constraints', () => {
+    it('passes min and max props to input', () => {
+      render(<FormDateInput {...defaultProps} min="2023-01-01" max="2025-01-01" />)
+
+      const input = screen.getByLabelText('Test Date')
+      expect(input).toHaveAttribute('min', '2023-01-01')
+      expect(input).toHaveAttribute('max', '2025-01-01')
+    })
+  })
+
+  describe('Styling and Structure', () => {
+    it('renders with correct container classes', () => {
+      const { container } = render(<FormDateInput {...defaultProps} />)
+
+      // The outer div in the component
+      const wrapper = container.firstChild as HTMLElement
+      expect(wrapper).toHaveClass('w-full', 'min-w-0')
+      expect(wrapper).toHaveStyle({ maxWidth: '100%', overflow: 'hidden' })
+    })
+
+    it('passes common class names to Input', () => {
+      render(<FormDateInput {...defaultProps} />)
+
+      const input = screen.getByLabelText('Test Date')
+      const classNames = JSON.parse(input.dataset.classNames || '{}')
+
+      expect(classNames).toEqual(
+        expect.objectContaining({
+          base: 'w-full min-w-0',
+          label: 'text-sm font-semibold text-gray-600 dark:text-gray-300',
+          input: 'text-gray-800 dark:text-gray-200',
+          inputWrapper: 'bg-gray-50 dark:bg-gray-800',
+          helperWrapper: 'min-w-0 max-w-full w-full',
+          errorMessage: 'break-words whitespace-normal max-w-full w-full',
+        })
+      )
+    })
+
+    it('sets label placement to outside', () => {
+      render(<FormDateInput {...defaultProps} />)
+      const input = screen.getByLabelText('Test Date')
+      expect(input).toHaveAttribute('data-label-placement', 'outside')
+    })
+  })
+})
diff --git a/frontend/__tests__/unit/components/skeletons/sharedSkeletons.test.tsx b/frontend/__tests__/unit/components/skeletons/sharedSkeletons.test.tsx
new file mode 100644
index 0000000000..1c374cd182
--- /dev/null
+++ b/frontend/__tests__/unit/components/skeletons/sharedSkeletons.test.tsx
@@ -0,0 +1,158 @@
+import { render, screen } from '@testing-library/react'
+import {
+  ItemCardSkeleton,
+  SectionSkeleton,
+  PageWrapper,
+  TitleSection,
+  TwoColumnSection,
+  SectionHeader,
+  CardSection,
+} from 'components/skeletons/sharedSkeletons'
+
+jest.mock('@heroui/skeleton', () => ({
+  Skeleton: ({ className, ...props }: { className?: string; [key: string]: unknown }) => (
+    <div data-testid="skeleton" className={className} {...props} />
+  ),
+}))
+
+describe('sharedSkeletons', () => {
+  describe('ItemCardSkeleton', () => {
+    it('renders with correct title width', () => {
+      render(<ItemCardSkeleton titleWidth="w-1/2" />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons[0]).toHaveClass('w-1/2')
+    })
+
+    it('renders correct structure', () => {
+      render(<ItemCardSkeleton titleWidth="w-1/3" />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons).toHaveLength(5)
+    })
+  })
+
+  describe('SectionSkeleton', () => {
+    it('renders correct number of items', () => {
+      render(
+        <SectionSkeleton
+          titleWidth="w-full"
+          itemCount={3}
+          itemKeyPrefix="test-item"
+          titleSkeletonWidth="w-32"
+        />
+      )
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons).toHaveLength(17)
+    })
+
+    it('applies minHeight class', () => {
+      const { container } = render(
+        <SectionSkeleton
+          titleWidth="w-full"
+          itemCount={1}
+          itemKeyPrefix="test"
+          titleSkeletonWidth="w-20"
+          minHeight="min-h-[200px]"
+        />
+      )
+      expect(container.firstChild).toHaveClass('min-h-[200px]')
+    })
+  })
+
+  describe('PageWrapper', () => {
+    it('renders children', () => {
+      render(
+        <PageWrapper>
+          <div data-testid="child">Child Content</div>
+        </PageWrapper>
+      )
+      expect(screen.getByTestId('child')).toBeInTheDocument()
+    })
+
+    it('sets aria-busy attribute', () => {
+      const { container } = render(
+        <PageWrapper ariaBusy={false}>
+          <div>Child</div>
+        </PageWrapper>
+      )
+      expect(container.firstChild).toHaveAttribute('aria-busy', 'false')
+    })
+
+    it('defaults aria-busy to true', () => {
+      const { container } = render(
+        <PageWrapper>
+          <div>Child</div>
+        </PageWrapper>
+      )
+      expect(container.firstChild).toHaveAttribute('aria-busy', 'true')
+    })
+  })
+
+  describe('TitleSection', () => {
+    it('renders with default class name', () => {
+      render(<TitleSection />)
+      const skeleton = screen.getByTestId('skeleton')
+      expect(skeleton).toHaveClass('h-10 w-64 rounded')
+    })
+
+    it('renders with custom class name', () => {
+      render(<TitleSection skeletonClassName="h-12 w-full" />)
+      const skeleton = screen.getByTestId('skeleton')
+      expect(skeleton).toHaveClass('h-12 w-full')
+    })
+  })
+
+  describe('TwoColumnSection', () => {
+    it('renders multiple sections', () => {
+      const sections = [
+        { keyPrefix: 's1', titleWidth: 'w-20', itemTitleWidth: 'w-full' },
+        { keyPrefix: 's2', titleWidth: 'w-30', itemTitleWidth: 'w-half' },
+      ]
+      render(<TwoColumnSection sections={sections} />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons).toHaveLength(54)
+    })
+  })
+
+  describe('SectionHeader', () => {
+    it('renders with rounded class when true', () => {
+      render(<SectionHeader titleSkeletonWidth="w-20" rounded={true} />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons[0]).toHaveClass('rounded')
+      expect(skeletons[1]).toHaveClass('rounded')
+    })
+
+    it('renders without rounded class when false', () => {
+      render(<SectionHeader titleSkeletonWidth="w-20" rounded={false} />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons[0]).not.toHaveClass('rounded', { exact: false })
+    })
+
+    it('renders correct title width', () => {
+      render(<SectionHeader titleSkeletonWidth="w-40" />)
+      const skeletons = screen.getAllByTestId('skeleton')
+      expect(skeletons[1]).toHaveClass('w-40')
+    })
+  })
+
+  describe('CardSection', () => {
+    it('renders children', () => {
+      render(
+        <CardSection>
+          <div data-testid="card-child">Content</div>
+        </CardSection>
+      )
+      expect(screen.getByTestId('card-child')).toBeInTheDocument()
+    })
+
+    it('applies custom classes, minHeight, and colSpan', () => {
+      const { container } = render(
+        <CardSection className="custom-class" minHeight="min-h-10" colSpan="col-span-2">
+          <div>Content</div>
+        </CardSection>
+      )
+      expect(container.firstChild).toHaveClass('custom-class')
+      expect(container.firstChild).toHaveClass('min-h-10')
+      expect(container.firstChild).toHaveClass('col-span-2')
+    })
+  })
+})
diff --git a/frontend/__tests__/unit/pages/ChapterDetails.test.tsx b/frontend/__tests__/unit/pages/ChapterDetails.test.tsx
index a9a4e1ec85..2d663ef00c 100644
--- a/frontend/__tests__/unit/pages/ChapterDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/ChapterDetails.test.tsx
@@ -151,4 +151,63 @@ describe('chapterDetailsPage Component', () => {
       expect(screen.getByText('Chapter Leader')).toBeInTheDocument()
     })
   })
+
+  test('handles missing suggestedLocation gracefully', async () => {
+    const chapterDataWithoutLocation = {
+      ...mockChapterDetailsData,
+      chapter: {
+        ...mockChapterDetailsData.chapter,
+        suggestedLocation: null,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: chapterDataWithoutLocation,
+      error: null,
+    })
+    render(<ChapterDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Test Chapter')).toBeInTheDocument()
+    })
+    expect(screen.queryByText('Test City, Test Country')).not.toBeInTheDocument()
+  })
+
+  test('handles missing region gracefully', async () => {
+    const chapterDataWithoutRegion = {
+      ...mockChapterDetailsData,
+      chapter: {
+        ...mockChapterDetailsData.chapter,
+        region: null,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: chapterDataWithoutRegion,
+      error: null,
+    })
+    render(<ChapterDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Test Chapter')).toBeInTheDocument()
+    })
+  })
+
+  test('handles missing suggestedLocation and region gracefully', async () => {
+    const chapterDataWithoutLocationAndRegion = {
+      ...mockChapterDetailsData,
+      chapter: {
+        ...mockChapterDetailsData.chapter,
+        suggestedLocation: undefined,
+        region: undefined,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: chapterDataWithoutLocationAndRegion,
+      error: null,
+    })
+    render(<ChapterDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Test Chapter')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Chapters.test.tsx b/frontend/__tests__/unit/pages/Chapters.test.tsx
index 0793d768e4..d5119349e6 100644
--- a/frontend/__tests__/unit/pages/Chapters.test.tsx
+++ b/frontend/__tests__/unit/pages/Chapters.test.tsx
@@ -161,4 +161,102 @@ describe('ChaptersPage Component', () => {
       expect(screen.getByText('Chapter 1')).toBeInTheDocument()
     })
   })
+
+  test('renders chapter card without relatedUrls', async () => {
+    const chapterWithoutUrls = {
+      ...mockChapterData.chapters[0],
+      relatedUrls: undefined,
+      key: 'chapter_no_urls',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [chapterWithoutUrls],
+      totalPages: 1,
+    })
+
+    render(<ChaptersPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Chapter 1')).toBeInTheDocument()
+    })
+  })
+
+  test('renders chapter card without objectID (uses key fallback)', async () => {
+    const chapterWithoutObjectID = {
+      ...mockChapterData.chapters[0],
+      objectID: undefined,
+      key: 'chapter_no_objectid',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [chapterWithoutObjectID],
+      totalPages: 1,
+    })
+
+    render(<ChaptersPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Chapter 1')).toBeInTheDocument()
+    })
+  })
+
+  test('renders chapter card without summary (uses empty string fallback)', async () => {
+    const chapterWithoutSummary = {
+      ...mockChapterData.chapters[0],
+      summary: undefined,
+      key: 'chapter_no_summary',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [chapterWithoutSummary],
+      totalPages: 1,
+    })
+
+    render(<ChaptersPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Chapter 1')).toBeInTheDocument()
+    })
+  })
+
+  test('filters out inactive chapters', async () => {
+    const activeChapter = {
+      ...mockChapterData.chapters[0],
+      name: 'Active Chapter',
+      key: 'active_chapter',
+      isActive: true,
+    }
+    const inactiveChapter = {
+      ...mockChapterData.chapters[0],
+      name: 'Inactive Chapter',
+      key: 'inactive_chapter',
+      isActive: false,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [activeChapter, inactiveChapter],
+      totalPages: 1,
+    })
+
+    render(<ChaptersPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Active Chapter')).toBeInTheDocument()
+    })
+    expect(screen.queryByText('Inactive Chapter')).not.toBeInTheDocument()
+  })
+
+  test('renders chapter with null relatedUrls', async () => {
+    const chapterWithNullUrls = {
+      ...mockChapterData.chapters[0],
+      relatedUrls: null,
+      key: 'chapter_null_urls',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [chapterWithNullUrls],
+      totalPages: 1,
+    })
+
+    render(<ChaptersPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Chapter 1')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Committees.test.tsx b/frontend/__tests__/unit/pages/Committees.test.tsx
index 825521e649..4971f2692f 100644
--- a/frontend/__tests__/unit/pages/Committees.test.tsx
+++ b/frontend/__tests__/unit/pages/Committees.test.tsx
@@ -143,4 +143,22 @@ describe('Committees Component', () => {
     //suppose index_key is committee_1
     expect(mockRouter.push).toHaveBeenCalledWith('/committees/committee_1')
   })
+
+  test('renders committee card without summary (uses empty string fallback)', async () => {
+    const committeeWithoutSummary = {
+      ...mockCommitteeData.committees[0],
+      summary: undefined,
+      key: 'committee_no_summary',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [committeeWithoutSummary],
+      totalPages: 1,
+    })
+
+    render(<CommitteesPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Committee 1')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Contribute.test.tsx b/frontend/__tests__/unit/pages/Contribute.test.tsx
index 08bbfcba58..35ea642839 100644
--- a/frontend/__tests__/unit/pages/Contribute.test.tsx
+++ b/frontend/__tests__/unit/pages/Contribute.test.tsx
@@ -243,4 +243,74 @@ describe('Contribute Component', () => {
       expect(viewIssueButton).toBeInTheDocument()
     })
   })
+
+  test('renders issue card without objectID (uses url fallback)', async () => {
+    const issueWithoutObjectID = {
+      ...mockContributeData.issues[0],
+      objectID: undefined,
+      url: 'https://github.com/test/issue/1',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [issueWithoutObjectID],
+      totalPages: 1,
+    })
+
+    render(<ContributePage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Contribution 1')).toBeInTheDocument()
+    })
+  })
+
+  test('renders issue card without summary (uses empty string fallback)', async () => {
+    const issueWithoutSummary = {
+      ...mockContributeData.issues[0],
+      summary: undefined,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [issueWithoutSummary],
+      totalPages: 1,
+    })
+
+    render(<ContributePage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Contribution 1')).toBeInTheDocument()
+    })
+  })
+
+  test('renders issue card with null objectID (uses url fallback)', async () => {
+    const issueWithNullObjectID = {
+      ...mockContributeData.issues[0],
+      objectID: null,
+      url: 'https://github.com/test/issue/2',
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [issueWithNullObjectID],
+      totalPages: 1,
+    })
+
+    render(<ContributePage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Contribution 1')).toBeInTheDocument()
+    })
+  })
+
+  test('renders issue card with null summary (uses empty string fallback)', async () => {
+    const issueWithNullSummary = {
+      ...mockContributeData.issues[0],
+      summary: null,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [issueWithNullSummary],
+      totalPages: 1,
+    })
+
+    render(<ContributePage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Contribution 1')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Home.test.tsx b/frontend/__tests__/unit/pages/Home.test.tsx
index 1fa3cdf5cf..43acda701c 100644
--- a/frontend/__tests__/unit/pages/Home.test.tsx
+++ b/frontend/__tests__/unit/pages/Home.test.tsx
@@ -339,4 +339,109 @@ describe('Home', () => {
       expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
     })
   })
+
+  test('renders project icons correctly for different types', async () => {
+    const mockProjectsData = {
+      ...mockGraphQLData,
+      recentProjects: [
+        { ...mockGraphQLData.recentProjects[0], key: 'p1', type: 'code', name: 'Code Project' },
+        {
+          ...mockGraphQLData.recentProjects[0],
+          key: 'p2',
+          type: 'documentation',
+          name: 'Doc Project',
+        },
+        { ...mockGraphQLData.recentProjects[0], key: 'p3', type: 'tool', name: 'Tool Project' },
+        { ...mockGraphQLData.recentProjects[0], key: 'p4', type: 'other', name: 'Other Project' },
+        {
+          ...mockGraphQLData.recentProjects[0],
+          key: 'p5',
+          type: 'unknown',
+          name: 'Unknown Project',
+        },
+      ],
+    }
+
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: mockProjectsData,
+      loading: false,
+      error: null,
+    })
+
+    render(<Home />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Code Project')).toBeInTheDocument()
+      expect(screen.getByText('Doc Project')).toBeInTheDocument()
+      expect(screen.getByText('Tool Project')).toBeInTheDocument()
+      expect(screen.getByText('Other Project')).toBeInTheDocument()
+      expect(screen.getByText('Unknown Project')).toBeInTheDocument()
+    })
+  })
+
+  test('handles null or undefined values in data gracefully', async () => {
+    const mockNullData = {
+      ...mockGraphQLData,
+      upcomingEvents: null,
+      topContributors: null,
+      sponsors: null,
+      statsOverview: {
+        activeProjectsStats: null,
+        activeChaptersStats: null,
+        contributorsStats: null,
+        countriesStats: null,
+        slackWorkspaceStats: null,
+      },
+    }
+
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: mockNullData,
+      loading: false,
+      error: null,
+    })
+
+    render(<Home />)
+
+    await waitFor(() => {
+      expect(screen.getByPlaceholderText('Search the OWASP community')).toBeInTheDocument()
+      expect(screen.queryByText('Top Contributors')).not.toBeInTheDocument()
+
+      const zeroStats = screen.getAllByText('Active Projects')
+      expect(zeroStats.length).toBeGreaterThan(0)
+    })
+  })
+
+  test('handles event with missing summary', async () => {
+    const mockEventData = {
+      ...mockGraphQLData,
+      upcomingEvents: [
+        {
+          ...mockGraphQLData.upcomingEvents[0],
+          summary: null,
+          suggestedLocation: null,
+          endDate: null,
+          name: 'Event No Summary',
+        },
+      ],
+    }
+
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: mockEventData,
+      loading: false,
+      error: null,
+    })
+
+    render(<Home />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Event No Summary')).toBeInTheDocument()
+    })
+
+    const eventButton = screen.getByText('Event No Summary')
+    fireEvent.click(eventButton)
+
+    await waitFor(() => {
+      expect(screen.getByText('The event summary has been generated by AI')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/MenteeProfilePage.test.tsx b/frontend/__tests__/unit/pages/MenteeProfilePage.test.tsx
index cf2bfae925..712e528cc7 100644
--- a/frontend/__tests__/unit/pages/MenteeProfilePage.test.tsx
+++ b/frontend/__tests__/unit/pages/MenteeProfilePage.test.tsx
@@ -99,6 +99,14 @@ jest.mock('@heroui/select', () => {
           >
             {selectedKey}
           </button>
+          <button
+            type="button"
+            data-testid="select-trigger-empty"
+            onClick={() => onSelectionChange?.(new Set())}
+            style={{ display: 'none' }}
+          >
+            Trigger Empty Selection
+          </button>
           {isOpen && (
             <div id="select-popover" data-testid="select-popover" aria-label="Options">
               {React.Children.map(children, (child: React.ReactElement) => {
@@ -441,4 +449,96 @@ describe('MenteeProfilePage', () => {
     expect(screen.queryByRole('heading', { name: /Domains/i })).not.toBeInTheDocument()
     expect(screen.getByRole('heading', { name: /Skills & Technologies/i })).toBeInTheDocument()
   })
+
+  it('handles issues with null labels using fallback', () => {
+    const dataWithNullLabels = {
+      ...mockMenteeData,
+      getMenteeModuleIssues: [
+        {
+          id: 'issue1',
+          number: 101,
+          title: 'Issue with null labels',
+          state: 'open',
+          url: 'http://example.com/issue1',
+          labels: null,
+        },
+      ],
+    }
+    mockUseQuery.mockReturnValue({ data: dataWithNullLabels, loading: false, error: undefined })
+    render(<MenteeProfilePage />)
+
+    expect(screen.getAllByText('Issue with null labels').length).toBeGreaterThan(0)
+  })
+
+  it('handles issues with undefined labels using fallback', () => {
+    const dataWithUndefinedLabels = {
+      ...mockMenteeData,
+      getMenteeModuleIssues: [
+        {
+          id: 'issue1',
+          number: 101,
+          title: 'Issue with undefined labels',
+          state: 'open',
+          url: 'http://example.com/issue1',
+          labels: undefined,
+        },
+      ],
+    }
+    mockUseQuery.mockReturnValue({
+      data: dataWithUndefinedLabels,
+      loading: false,
+      error: undefined,
+    })
+    render(<MenteeProfilePage />)
+
+    expect(screen.getAllByText('Issue with undefined labels').length).toBeGreaterThan(0)
+  })
+
+  it('handles null domains with nullish coalescing', () => {
+    const dataWithNullDomains = {
+      ...mockMenteeData,
+      getMenteeDetails: {
+        ...mockMenteeData.getMenteeDetails,
+        domains: null,
+        tags: ['react'],
+      },
+    }
+    mockUseQuery.mockReturnValue({ data: dataWithNullDomains, loading: false, error: undefined })
+    render(<MenteeProfilePage />)
+
+    expect(screen.queryByRole('heading', { name: /Domains/i })).not.toBeInTheDocument()
+    expect(screen.getByRole('heading', { name: /Skills & Technologies/i })).toBeInTheDocument()
+  })
+
+  it('handles null tags with nullish coalescing', () => {
+    const dataWithNullTags = {
+      ...mockMenteeData,
+      getMenteeDetails: {
+        ...mockMenteeData.getMenteeDetails,
+        domains: ['frontend'],
+        tags: null,
+      },
+    }
+    mockUseQuery.mockReturnValue({ data: dataWithNullTags, loading: false, error: undefined })
+    render(<MenteeProfilePage />)
+
+    expect(screen.getByRole('heading', { name: /Domains/i })).toBeInTheDocument()
+    expect(
+      screen.queryByRole('heading', { name: /Skills & Technologies/i })
+    ).not.toBeInTheDocument()
+  })
+
+  it('does not change filter when selection is empty', () => {
+    mockUseQuery.mockReturnValue({ data: mockMenteeData, loading: false, error: undefined })
+    render(<MenteeProfilePage />)
+
+    expect(screen.getAllByText('Open Issue 1').length).toBeGreaterThan(0)
+    expect(screen.getAllByText('Closed Issue 1').length).toBeGreaterThan(0)
+
+    const emptyTrigger = screen.getByTestId('select-trigger-empty')
+    fireEvent.click(emptyTrigger)
+
+    expect(screen.getAllByText('Open Issue 1').length).toBeGreaterThan(0)
+    expect(screen.getAllByText('Closed Issue 1').length).toBeGreaterThan(0)
+  })
 })
diff --git a/frontend/__tests__/unit/pages/ModuleDetails.test.tsx b/frontend/__tests__/unit/pages/ModuleDetails.test.tsx
index 2d82af0111..db4eea7b29 100644
--- a/frontend/__tests__/unit/pages/ModuleDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/ModuleDetails.test.tsx
@@ -117,4 +117,52 @@ describe('ModuleDetailsPage', () => {
     expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
     expect(screen.getByTestId('details-card')).toHaveTextContent('A beginner friendly module.')
   })
+
+  it('renders module without admins (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: mockModuleData,
+        getProgram: {
+          admins: null,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
+
+  it('renders module without domains (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: { ...mockModuleData, domains: null },
+        getProgram: {
+          admins,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
+
+  it('renders module without tags (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: { ...mockModuleData, tags: null },
+        getProgram: {
+          admins,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
 })
diff --git a/frontend/__tests__/unit/pages/ModuleDetailsPage.test.tsx b/frontend/__tests__/unit/pages/ModuleDetailsPage.test.tsx
index b1e6e78911..3b9b040d26 100644
--- a/frontend/__tests__/unit/pages/ModuleDetailsPage.test.tsx
+++ b/frontend/__tests__/unit/pages/ModuleDetailsPage.test.tsx
@@ -80,4 +80,52 @@ describe('ModuleDetailsPage', () => {
     expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
     expect(screen.getByTestId('details-card')).toHaveTextContent('A beginner friendly module.')
   })
+
+  it('renders module without admins (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: mockModuleData,
+        getProgram: {
+          admins: null,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
+
+  it('renders module without domains (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: { ...mockModuleData, domains: null },
+        getProgram: {
+          admins,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
+
+  it('renders module without tags (uses undefined fallback)', async () => {
+    mockUseQuery.mockReturnValue({
+      loading: false,
+      data: {
+        getModule: { ...mockModuleData, tags: null },
+        getProgram: {
+          admins,
+        },
+      },
+    })
+
+    render(<ModuleDetailsPage />)
+
+    expect(await screen.findByTestId('details-card')).toHaveTextContent('Intro to Web')
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Organization.test.tsx b/frontend/__tests__/unit/pages/Organization.test.tsx
index 8937bdf597..a945cf86cc 100644
--- a/frontend/__tests__/unit/pages/Organization.test.tsx
+++ b/frontend/__tests__/unit/pages/Organization.test.tsx
@@ -135,4 +135,43 @@ describe('Organization', () => {
     expect(screen.getByText('@no-optional-org')).toBeInTheDocument()
     expect(screen.getByText('@empty-strings-org')).toBeInTheDocument()
   })
+
+  test('renders organization card with null avatarUrl using fallback', async () => {
+    const mockDataWithNullAvatar = {
+      hits: [
+        {
+          objectID: 'org-null-avatar',
+          avatarUrl: null,
+          collaboratorsCount: 5,
+          company: 'Test Company',
+          createdAt: 1596744799,
+          description: 'Organization with null avatar',
+          email: 'test@example.com',
+          followersCount: 50,
+          location: 'Test Location',
+          login: 'null-avatar-org',
+          name: 'Null Avatar Org',
+          publicRepositoriesCount: 25,
+          updatedAt: 1727390473,
+          url: 'https://github.com/null-avatar-org',
+        },
+      ],
+      totalPages: 1,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue(mockDataWithNullAvatar)
+
+    render(<Organization />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Null Avatar Org')).toBeInTheDocument()
+      expect(screen.queryByAltText("Null Avatar Org's profile picture")).not.toBeInTheDocument()
+    })
+
+    const cards = screen.getAllByRole('button')
+    const nullAvatarCard = cards.find((card) => card.textContent?.includes('Null Avatar Org'))
+    expect(nullAvatarCard).toBeInTheDocument()
+
+    const fallbackContainer = nullAvatarCard?.querySelector('.bg-gray-200')
+    expect(fallbackContainer).toBeInTheDocument()
+  })
 })
diff --git a/frontend/__tests__/unit/pages/OrganizationDetails.test.tsx b/frontend/__tests__/unit/pages/OrganizationDetails.test.tsx
index eb9a72076d..45d4f3b5e3 100644
--- a/frontend/__tests__/unit/pages/OrganizationDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/OrganizationDetails.test.tsx
@@ -210,4 +210,33 @@ describe('OrganizationDetailsPage', () => {
       expect(screen.queryByText('Want to become a sponsor?')).toBeNull()
     })
   })
+
+  test('handles repositories with null organization gracefully', async () => {
+    const dataWithNullOrgRepo = {
+      ...mockOrganizationDetailsData,
+      repositories: [
+        {
+          name: 'test-repo',
+          url: 'https://github.com/test-org/test-repo',
+          contributorsCount: 10,
+          forksCount: 100,
+          openIssuesCount: 20,
+          starsCount: 500,
+          key: 'test-org/test-repo',
+          organization: null,
+        },
+      ],
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullOrgRepo,
+      loading: false,
+      error: null,
+    })
+
+    render(<OrganizationDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByRole('heading', { name: 'Test Organization' })).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/ProgramDetails.test.tsx b/frontend/__tests__/unit/pages/ProgramDetails.test.tsx
index ea6db51e63..0fbc93c1a7 100644
--- a/frontend/__tests__/unit/pages/ProgramDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/ProgramDetails.test.tsx
@@ -103,4 +103,49 @@ describe('ProgramDetailsPage', () => {
       expect(screen.getByText('N/A')).toBeInTheDocument()
     })
   })
+
+  test('renders program without admins (uses undefined fallback)', async () => {
+    const mockDataWithoutAdmins = {
+      getProgram: { ...mockProgramDetailsData.getProgram, admins: null },
+      getProgramModules: mockProgramDetailsData.getProgramModules,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutAdmins,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
+
+  test('renders program without domains (uses undefined fallback)', async () => {
+    const mockDataWithoutDomains = {
+      getProgram: { ...mockProgramDetailsData.getProgram, domains: null },
+      getProgramModules: mockProgramDetailsData.getProgramModules,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutDomains,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
+
+  test('renders program without tags (uses undefined fallback)', async () => {
+    const mockDataWithoutTags = {
+      getProgram: { ...mockProgramDetailsData.getProgram, tags: null },
+      getProgramModules: mockProgramDetailsData.getProgramModules,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutTags,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/ProgramDetailsMentorship.test.tsx b/frontend/__tests__/unit/pages/ProgramDetailsMentorship.test.tsx
index 8e4789b855..cde5ffeb41 100644
--- a/frontend/__tests__/unit/pages/ProgramDetailsMentorship.test.tsx
+++ b/frontend/__tests__/unit/pages/ProgramDetailsMentorship.test.tsx
@@ -1,12 +1,48 @@
 import { useQuery, useMutation } from '@apollo/client/react'
+import { addToast } from '@heroui/toast'
 import mockProgramDetailsData from '@mockData/mockProgramData'
 import { screen, waitFor, fireEvent } from '@testing-library/react'
 import { useSession } from 'next-auth/react'
 import { render } from 'wrappers/testUtil'
+import { handleAppError } from 'app/global-error'
 import ProgramDetailsPage from 'app/my/mentorship/programs/[programKey]/page'
 import '@testing-library/jest-dom'
 import { ProgramStatusEnum } from 'types/__generated__/graphql'
 
+let capturedSetStatus: ((status: string) => void) | null = null
+
+jest.mock('components/CardDetailsPage', () => {
+  return jest.fn((props) => {
+    capturedSetStatus = props.setStatus
+    return (
+      <div data-testid="details-card">
+        <h1>{props.title}</h1>
+        <p>{props.summary}</p>
+        <div data-testid="details-content">
+          {props.details?.map((detail: { label: string; value: string }) => (
+            <div key={detail.label}>
+              <span>{detail.label}</span>
+              <span>{detail.value}</span>
+            </div>
+          ))}
+        </div>
+        {props.canUpdateStatus && (
+          <div>
+            <button aria-label="Program actions menu">Program actions menu</button>
+            <button role="menuitem" onClick={() => props.setStatus && props.setStatus('PUBLISHED')}>
+              Publish
+            </button>
+          </div>
+        )}
+      </div>
+    )
+  })
+})
+
+jest.mock('@heroui/toast', () => ({
+  addToast: jest.fn(),
+}))
+
 jest.mock('@apollo/client/react', () => ({
   ...jest.requireActual('@apollo/client/react'),
   useQuery: jest.fn(),
@@ -25,8 +61,16 @@ jest.mock('next-auth/react', () => ({
   useSession: jest.fn(),
 }))
 
+jest.mock('app/global-error', () => ({
+  handleAppError: jest.fn(),
+  ErrorDisplay: ({ title }: { title: string }) => <div>{title}</div>,
+}))
+
 describe('ProgramDetailsPage', () => {
   beforeEach(() => {
+    capturedSetStatus = null
+    ;(addToast as jest.Mock).mockClear()
+    ;(handleAppError as jest.Mock).mockClear()
     ;(useQuery as unknown as jest.Mock).mockReturnValue({
       data: mockProgramDetailsData,
       loading: false,
@@ -147,5 +191,209 @@ describe('ProgramDetailsPage', () => {
         })
       })
     })
+
+    test('shows error toast when trying to update with invalid status', async () => {
+      render(<ProgramDetailsPage />)
+
+      await waitFor(() => {
+        expect(screen.getByTestId('details-card')).toBeInTheDocument()
+      })
+
+      expect(capturedSetStatus).not.toBeNull()
+      capturedSetStatus!('INVALID_STATUS')
+
+      await waitFor(() => {
+        expect(addToast).toHaveBeenCalledWith({
+          color: 'danger',
+          description: 'The provided status is not valid.',
+          timeout: 3000,
+          title: 'Invalid Status',
+          variant: 'solid',
+        })
+        expect(mockUpdateProgram).not.toHaveBeenCalled()
+      })
+    })
+
+    test('handles mutation error gracefully', async () => {
+      const mockError = new Error('Mutation failed')
+      mockUpdateProgram.mockRejectedValue(mockError)
+
+      render(<ProgramDetailsPage />)
+
+      const actionsButton = await screen.findByRole('button', { name: /Program actions menu/ })
+      fireEvent.click(actionsButton)
+
+      const publishButton = await screen.findByRole('menuitem', { name: 'Publish' })
+      fireEvent.click(publishButton)
+
+      await waitFor(() => {
+        expect(mockUpdateProgram).toHaveBeenCalled()
+        expect(handleAppError).toHaveBeenCalledWith(mockError)
+      })
+    })
+  })
+
+  test('renders program with null admins (uses undefined fallback)', async () => {
+    const mockDataWithoutAdmins = {
+      getProgram: { ...mockProgramDetailsData.getProgram, admins: null },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutAdmins,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
+
+  test('renders program with null domains (uses undefined fallback)', async () => {
+    const mockDataWithoutDomains = {
+      getProgram: { ...mockProgramDetailsData.getProgram, domains: null },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutDomains,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
+
+  test('renders program with null tags (uses undefined fallback)', async () => {
+    const mockDataWithoutTags = {
+      getProgram: { ...mockProgramDetailsData.getProgram, tags: null },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithoutTags,
+    })
+    render(<ProgramDetailsPage />)
+    await waitFor(() => {
+      expect(screen.getByText('Test Program')).toBeInTheDocument()
+    })
+  })
+
+  test('calls addToast with permission denied when non-admin calls setStatus', async () => {
+    const mockUpdateProgram = jest.fn()
+    ;(useMutation as unknown as jest.Mock).mockReturnValue([mockUpdateProgram, { loading: false }])
+    ;(useSession as jest.Mock).mockReturnValue({
+      data: { user: { login: 'non-admin-user' } },
+      status: 'authenticated',
+    })
+
+    render(<ProgramDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('details-card')).toBeInTheDocument()
+    })
+
+    if (capturedSetStatus) {
+      capturedSetStatus(ProgramStatusEnum.Published)
+    }
+
+    await waitFor(() => {
+      expect(addToast).toHaveBeenCalledWith({
+        color: 'danger',
+        description: 'Only admins can update the program status.',
+        timeout: 3000,
+        title: 'Permission Denied',
+        variant: 'solid',
+      })
+    })
+  })
+
+  test('calls addToast with success when admin successfully updates status', async () => {
+    const mockUpdateProgram = jest.fn().mockResolvedValue({})
+    ;(useMutation as unknown as jest.Mock).mockReturnValue([mockUpdateProgram, { loading: false }])
+    ;(useSession as jest.Mock).mockReturnValue({
+      data: { user: { login: 'admin-user' } },
+      status: 'authenticated',
+    })
+
+    render(<ProgramDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('details-card')).toBeInTheDocument()
+    })
+
+    if (capturedSetStatus) {
+      await capturedSetStatus(ProgramStatusEnum.Published)
+    }
+
+    await waitFor(() => {
+      expect(mockUpdateProgram).toHaveBeenCalledWith({
+        variables: {
+          inputData: {
+            key: 'test-program',
+            name: 'Test Program',
+            status: ProgramStatusEnum.Published,
+          },
+        },
+      })
+      expect(addToast).toHaveBeenCalledWith({
+        title: 'Program status updated to Published',
+        description: 'The status has been successfully updated.',
+        variant: 'solid',
+        color: 'success',
+        timeout: 3000,
+      })
+    })
+  })
+
+  test('calls handleAppError when mutation fails', async () => {
+    const mockError = new Error('Mutation failed')
+    const mockUpdateProgram = jest.fn().mockRejectedValue(mockError)
+    ;(useMutation as unknown as jest.Mock).mockReturnValue([mockUpdateProgram, { loading: false }])
+    ;(useSession as jest.Mock).mockReturnValue({
+      data: { user: { login: 'admin-user' } },
+      status: 'authenticated',
+    })
+
+    render(<ProgramDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('details-card')).toBeInTheDocument()
+    })
+
+    if (capturedSetStatus) {
+      await capturedSetStatus(ProgramStatusEnum.Published)
+    }
+
+    await waitFor(() => {
+      expect(mockUpdateProgram).toHaveBeenCalled()
+      expect(handleAppError).toHaveBeenCalledWith(mockError)
+    })
+  })
+
+  test('renders program with minimal details ensuring default values are used', async () => {
+    const mockDataWithNullFields = {
+      getProgram: {
+        ...mockProgramDetailsData.getProgram,
+        status: null,
+        startedAt: null,
+        endedAt: null,
+        menteesLimit: null,
+        key: null,
+        description: null,
+        name: null,
+      },
+      getProgramModules: [],
+    }
+
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      loading: false,
+      data: mockDataWithNullFields,
+    })
+
+    render(<ProgramDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('details-card')).toBeInTheDocument()
+
+      const detailsContent = screen.getByTestId('details-content')
+      expect(detailsContent).toHaveTextContent('Mentees Limit0')
+    })
   })
 })
diff --git a/frontend/__tests__/unit/pages/ProjectHealthDashboardMetricsDetails.test.tsx b/frontend/__tests__/unit/pages/ProjectHealthDashboardMetricsDetails.test.tsx
index 68bd47ab26..05bb923ef4 100644
--- a/frontend/__tests__/unit/pages/ProjectHealthDashboardMetricsDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/ProjectHealthDashboardMetricsDetails.test.tsx
@@ -154,4 +154,110 @@ describe('ProjectHealthMetricsDetails', () => {
       expect(screen.getByText('Leader Requirements Not Compliant')).toBeInTheDocument()
     })
   })
+
+  test('handles null createdAt in metrics list gracefully', async () => {
+    const dataWithNullCreatedAt = {
+      ...mockProjectsDashboardMetricsDetailsData,
+      project: {
+        ...mockProjectsDashboardMetricsDetailsData.project,
+        healthMetricsList: [
+          {
+            ...mockProjectsDashboardMetricsDetailsData.project.healthMetricsList[0],
+            createdAt: null,
+          },
+        ],
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullCreatedAt,
+      loading: false,
+      error: null,
+    })
+
+    render(<ProjectHealthMetricsDetails />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Stars')).toBeInTheDocument()
+      expect(screen.getByText('Forks')).toBeInTheDocument()
+      expect(screen.getByText('Issues')).toBeInTheDocument()
+      const charts = screen.getAllByTestId('mock-apexcharts')
+      expect(charts.length).toBeGreaterThan(0)
+    })
+  })
+
+  test('handles null score and compliance flags gracefully', async () => {
+    const dataWithNullValues = {
+      ...mockProjectsDashboardMetricsDetailsData,
+      project: {
+        ...mockProjectsDashboardMetricsDetailsData.project,
+        healthMetricsLatest: {
+          ...mockProjectsDashboardMetricsDetailsData.project.healthMetricsLatest,
+          score: null,
+          isFundingRequirementsCompliant: null,
+          isLeaderRequirementsCompliant: null,
+        },
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullValues,
+      loading: false,
+      error: null,
+    })
+
+    render(<ProjectHealthMetricsDetails />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Funding Requirements Not Compliant')).toBeInTheDocument()
+      expect(screen.getByText('Leader Requirements Not Compliant')).toBeInTheDocument()
+    })
+  })
+
+  test('handles null metric counts gracefully', async () => {
+    const dataWithNullCounts = {
+      ...mockProjectsDashboardMetricsDetailsData,
+      project: {
+        ...mockProjectsDashboardMetricsDetailsData.project,
+        healthMetricsList: [
+          {
+            ...mockProjectsDashboardMetricsDetailsData.project.healthMetricsList[0],
+            starsCount: null,
+            forksCount: null,
+            openIssuesCount: null,
+            unassignedIssuesCount: null,
+            unansweredIssuesCount: null,
+            totalIssuesCount: null,
+            openPullRequestsCount: null,
+            recentReleasesCount: null,
+            totalReleasesCount: null,
+            contributorsCount: null,
+          },
+        ],
+        healthMetricsLatest: {
+          ...mockProjectsDashboardMetricsDetailsData.project.healthMetricsLatest,
+          ageDays: null,
+          lastCommitDays: null,
+          lastReleaseDays: null,
+          lastPullRequestDays: null,
+          owaspPageLastUpdateDays: null,
+          ageDaysRequirement: null,
+          lastCommitDaysRequirement: null,
+          lastReleaseDaysRequirement: null,
+          lastPullRequestDaysRequirement: null,
+          owaspPageLastUpdateDaysRequirement: null,
+        },
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullCounts,
+      loading: false,
+      error: null,
+    })
+
+    render(<ProjectHealthMetricsDetails />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Days Metrics')).toBeInTheDocument()
+      expect(screen.getByText('Stars')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/Projects.test.tsx b/frontend/__tests__/unit/pages/Projects.test.tsx
index c8a8399fcc..829bc5c1b2 100644
--- a/frontend/__tests__/unit/pages/Projects.test.tsx
+++ b/frontend/__tests__/unit/pages/Projects.test.tsx
@@ -153,4 +153,42 @@ describe('ProjectPage Component', () => {
 
     jest.restoreAllMocks()
   })
+
+  test('handles project with null key gracefully', async () => {
+    const projectWithNullKey = {
+      ...mockProjectData.projects[0],
+      key: null,
+      name: 'Project Without Key',
+      isActive: true,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [projectWithNullKey],
+      totalPages: 1,
+    })
+
+    render(<ProjectsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Project Without Key')).toBeInTheDocument()
+    })
+  })
+
+  test('handles project with null summary gracefully', async () => {
+    const projectWithNullSummary = {
+      ...mockProjectData.projects[0],
+      summary: null,
+      name: 'Project Without Summary',
+      isActive: true,
+    }
+    ;(fetchAlgoliaData as jest.Mock).mockResolvedValue({
+      hits: [projectWithNullSummary],
+      totalPages: 1,
+    })
+
+    render(<ProjectsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Project Without Summary')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/RepositoryDetails.test.tsx b/frontend/__tests__/unit/pages/RepositoryDetails.test.tsx
index 226eba0fd6..c28c160b8f 100644
--- a/frontend/__tests__/unit/pages/RepositoryDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/RepositoryDetails.test.tsx
@@ -229,4 +229,96 @@ describe('RepositoryDetailsPage', () => {
       ).toBeInTheDocument()
     })
   })
+
+  test('handles issue with null author gracefully', async () => {
+    const dataWithNullAuthor = {
+      ...mockRepositoryData,
+      repository: {
+        ...mockRepositoryData.repository,
+        issues: [
+          {
+            title: 'Issue without author',
+            createdAt: 1727390000,
+            url: 'https://github.com/test-org/test-repo/issues/1',
+            repositoryName: 'test-repo',
+            author: null,
+          },
+        ],
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullAuthor,
+      loading: false,
+      error: null,
+    })
+
+    render(<RepositoryDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Issue without author')).toBeInTheDocument()
+    })
+  })
+
+  test('handles null recentIssues gracefully', async () => {
+    const dataWithNullIssues = {
+      ...mockRepositoryData,
+      repository: {
+        ...mockRepositoryData.repository,
+        issues: null,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullIssues,
+      loading: false,
+      error: null,
+    })
+
+    render(<RepositoryDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Repo')).toBeInTheDocument()
+    })
+  })
+
+  test('handles null recentMilestones gracefully', async () => {
+    const dataWithNullMilestones = {
+      ...mockRepositoryData,
+      repository: {
+        ...mockRepositoryData.repository,
+        recentMilestones: null,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullMilestones,
+      loading: false,
+      error: null,
+    })
+
+    render(<RepositoryDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Repo')).toBeInTheDocument()
+    })
+  })
+
+  test('handles null releases gracefully', async () => {
+    const dataWithNullReleases = {
+      ...mockRepositoryData,
+      repository: {
+        ...mockRepositoryData.repository,
+        releases: null,
+      },
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: dataWithNullReleases,
+      loading: false,
+      error: null,
+    })
+
+    render(<RepositoryDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Repo')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/pages/SnapshotDetails.test.tsx b/frontend/__tests__/unit/pages/SnapshotDetails.test.tsx
index 60f48db4b9..1a20809d93 100644
--- a/frontend/__tests__/unit/pages/SnapshotDetails.test.tsx
+++ b/frontend/__tests__/unit/pages/SnapshotDetails.test.tsx
@@ -188,4 +188,216 @@ describe('SnapshotDetailsPage', () => {
       expect(screen.queryByText('New Releases')).not.toBeInTheDocument()
     })
   })
+
+  test('renders project card with null key (uses name fallback)', async () => {
+    const projectWithNullKey = {
+      ...mockSnapshotDetailsData.snapshot.newProjects[0],
+      key: null,
+      name: 'Test Project',
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newProjects: [projectWithNullKey],
+          newChapters: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+      loading: false,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Project')).toBeInTheDocument()
+    })
+  })
+
+  test('renders project card without level', async () => {
+    const projectWithoutLevel = {
+      ...mockSnapshotDetailsData.snapshot.newProjects[0],
+      level: undefined,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newProjects: [projectWithoutLevel],
+          newChapters: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Nest')).toBeInTheDocument()
+    })
+  })
+
+  test('renders project card without summary', async () => {
+    const projectWithoutSummary = {
+      ...mockSnapshotDetailsData.snapshot.newProjects[0],
+      summary: undefined,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newProjects: [projectWithoutSummary],
+          newChapters: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Nest')).toBeInTheDocument()
+    })
+  })
+
+  test('renders chapter card without relatedUrls', async () => {
+    const chapterWithoutUrls = {
+      ...mockSnapshotDetailsData.snapshot.newChapters[0],
+      relatedUrls: undefined,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newChapters: [chapterWithoutUrls],
+          newProjects: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Sivagangai')).toBeInTheDocument()
+    })
+  })
+
+  test('renders chapter card without summary', async () => {
+    const chapterWithoutSummary = {
+      ...mockSnapshotDetailsData.snapshot.newChapters[0],
+      summary: undefined,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newChapters: [chapterWithoutSummary],
+          newProjects: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('OWASP Sivagangai')).toBeInTheDocument()
+    })
+  })
+
+  test('filters out inactive chapters', async () => {
+    const activeChapter = {
+      ...mockSnapshotDetailsData.snapshot.newChapters[0],
+      name: 'Active Chapter',
+      key: 'active-chapter',
+      isActive: true,
+    }
+    const inactiveChapter = {
+      ...mockSnapshotDetailsData.snapshot.newChapters[0],
+      name: 'Inactive Chapter',
+      key: 'inactive-chapter',
+      isActive: false,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newChapters: [activeChapter, inactiveChapter],
+          newProjects: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Active Chapter')).toBeInTheDocument()
+    })
+    expect(screen.queryByText('Inactive Chapter')).not.toBeInTheDocument()
+  })
+
+  test('filters out inactive projects', async () => {
+    const activeProject = {
+      ...mockSnapshotDetailsData.snapshot.newProjects[0],
+      name: 'Active Project',
+      key: 'active-project',
+      isActive: true,
+    }
+    const inactiveProject = {
+      ...mockSnapshotDetailsData.snapshot.newProjects[0],
+      name: 'Inactive Project',
+      key: 'inactive-project',
+      isActive: false,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newProjects: [activeProject, inactiveProject],
+          newChapters: [],
+          newReleases: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('Active Project')).toBeInTheDocument()
+    })
+    expect(screen.queryByText('Inactive Project')).not.toBeInTheDocument()
+  })
+
+  test('renders release without id (uses fallback key)', async () => {
+    const releaseWithoutId = {
+      ...mockSnapshotDetailsData.snapshot.newReleases[0],
+      id: undefined,
+    }
+    ;(useQuery as unknown as jest.Mock).mockReturnValue({
+      data: {
+        snapshot: {
+          ...mockSnapshotDetailsData.snapshot,
+          newReleases: [releaseWithoutId],
+          newChapters: [],
+          newProjects: [],
+        },
+      },
+      error: null,
+    })
+
+    render(<SnapshotDetailsPage />)
+
+    await waitFor(() => {
+      expect(screen.getByText('v0.9.2')).toBeInTheDocument()
+    })
+  })
 })
diff --git a/frontend/__tests__/unit/utils/proxy.test.ts b/frontend/__tests__/unit/utils/proxy.test.ts
index 1ca07062f9..27a4f50a10 100644
--- a/frontend/__tests__/unit/utils/proxy.test.ts
+++ b/frontend/__tests__/unit/utils/proxy.test.ts
@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { getToken } from 'next-auth/jwt'
-import proxy from 'proxy'
+import proxy, { config } from 'proxy'
 
 // Mock the external dependencies
 jest.mock('next-auth/jwt', () => ({
@@ -18,6 +18,11 @@ jest.mock('next/server', () => ({
 }))
 
 describe('Authentication Proxy', () => {
+  it('should export valid config', () => {
+    expect(config).toBeDefined()
+    expect(config.matcher).toEqual(expect.arrayContaining(['/my/mentorship/:path*']))
+  })
+
   const mockRequest = (url = 'http://localhost/'): NextRequest =>
     ({
       url,
diff --git a/frontend/src/components/Milestones.tsx b/frontend/src/components/Milestones.tsx
index 5f68e82c6b..5c3d9391b6 100644
--- a/frontend/src/components/Milestones.tsx
+++ b/frontend/src/components/Milestones.tsx
@@ -59,7 +59,7 @@ const Milestones: React.FC<ProjectMilestonesProps> = ({
                 className="cursor-pointer overflow-hidden text-ellipsis whitespace-nowrap text-gray-600 hover:underline dark:text-gray-400"
                 onClick={() =>
                   router.push(
-                    `/organizations/${item.organizationName}/repositories/${item.repositoryName || ''}`
+                    `/organizations/${item.organizationName}/repositories/${item.repositoryName}`
                   )
                 }
               >
diff --git a/frontend/src/components/Pagination.tsx b/frontend/src/components/Pagination.tsx
index ce98ef5f0e..18d1f893f3 100644
--- a/frontend/src/components/Pagination.tsx
+++ b/frontend/src/components/Pagination.tsx
@@ -37,18 +37,14 @@ const Pagination: React.FC<PaginationProps> = ({
       i <= Math.min(totalPages - 1, currentPage + 1);
       i++
     ) {
-      if (!pageNumbers.includes(i)) {
-        pageNumbers.push(i)
-      }
+      pageNumbers.push(i)
     }
 
     if (currentPage < totalPages - 3) {
       pageNumbers.push('...')
     }
 
-    if (totalPages > 3 && !pageNumbers.includes(totalPages)) {
-      pageNumbers.push(totalPages)
-    }
+    pageNumbers.push(totalPages)
 
     return pageNumbers
   }
diff --git a/frontend/src/components/SecondaryCard.tsx b/frontend/src/components/SecondaryCard.tsx
index 750f9a4e41..ee0a6cb2b0 100644
--- a/frontend/src/components/SecondaryCard.tsx
+++ b/frontend/src/components/SecondaryCard.tsx
@@ -12,7 +12,7 @@ const SecondaryCard = ({
   icon?: IconType
   children?: React.ReactNode
   className?: string
-} = {}) => (
+}) => (
   <div className={`mb-8 rounded-lg bg-gray-100 p-6 shadow-md dark:bg-gray-800 ${className}`}>
     {title && (
       <h2 className="mb-4 flex flex-row items-center gap-2 text-2xl font-semibold">