work on increasinf test coverage

Signed-off-by: vsanghishetty <vishali.kamenani@ymail.com>

Author: vishsanghishetty

frontend/packages/multicluster-sdk/src/api/useFleetK8sAPIPath.test.ts

@@ -0,0 +1,128 @@
+/* Copyright Contributors to the Open Cluster Management project */
+import { renderHook } from '@testing-library/react-hooks'
+import { useFleetK8sAPIPath, getFleetK8sAPIPath } from './useFleetK8sAPIPath'
+import { useHubClusterName } from './useHubClusterName'
+
+// Mock dependencies
+jest.mock('./useHubClusterName')
+jest.mock('../internal/constants', () => ({
+  BASE_K8S_API_PATH: '/api/kubernetes',
+  MANAGED_CLUSTER_API_PATH: 'api/clusters',
+  LOCAL_CLUSTER_LABEL: 'local-cluster',
+  NO_MULTICLUSTER: 'NO_MULTICLUSTER',
+}))
+
+jest.mock('./apiRequests', () => ({
+  k8sListItems: jest.fn(),
+  getBackendUrl: () => 'http://localhost:9000',
+}))
+
+const mockUseHubClusterName = useHubClusterName as jest.MockedFunction<typeof useHubClusterName>
+
+describe('useFleetK8sAPIPath', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should return base path when no cluster is provided', () => {
+    mockUseHubClusterName.mockReturnValue(['hub-cluster', true, undefined])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath())
+
+    expect(result.current).toEqual(['/api/kubernetes', true, undefined])
+  })
+
+  it('should return base path when cluster equals hub cluster', () => {
+    mockUseHubClusterName.mockReturnValue(['hub-cluster', true, undefined])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath('hub-cluster'))
+
+    expect(result.current).toEqual(['/api/kubernetes', true, undefined])
+  })
+
+  it('should return managed cluster path when cluster differs from hub cluster', () => {
+    mockUseHubClusterName.mockReturnValue(['hub-cluster', true, undefined])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath('managed-cluster-1'))
+
+    expect(result.current).toEqual(['http://localhost:9000/api/clusters/managed-cluster-1', true, undefined])
+  })
+
+  it('should return undefined when not loaded', () => {
+    mockUseHubClusterName.mockReturnValue([undefined, false, undefined])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath('managed-cluster-1'))
+
+    expect(result.current).toEqual([undefined, false, undefined])
+  })
+
+  it('should return managed cluster path when there is an error getting hub cluster name', () => {
+    mockUseHubClusterName.mockReturnValue([undefined, true, new Error('Test error')])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath('managed-cluster-1'))
+
+    expect(result.current).toEqual([
+      'http://localhost:9000/api/clusters/managed-cluster-1',
+      true,
+      new Error('Test error'),
+    ])
+  })
+
+  it('should return managed cluster path when hub cluster name is NO_MULTICLUSTER', () => {
+    mockUseHubClusterName.mockReturnValue(['NO_MULTICLUSTER', true, undefined])
+
+    const { result } = renderHook(() => useFleetK8sAPIPath('managed-cluster-1'))
+
+    expect(result.current).toEqual(['http://localhost:9000/api/clusters/managed-cluster-1', true, undefined])
+  })
+})
+
+describe('getFleetK8sAPIPath', () => {
+  const { k8sListItems } = jest.requireMock('./apiRequests')
+  const mockK8sListItems = k8sListItems as jest.MockedFunction<typeof k8sListItems>
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Clear the cached hub cluster name between tests
+    jest.resetModules()
+  })
+
+  it('should return base path when no cluster is provided', async () => {
+    const result = await getFleetK8sAPIPath()
+    expect(result).toBe('/api/kubernetes')
+  })
+
+  it('should return managed cluster path when cluster is provided and hub cluster is found', async () => {
+    mockK8sListItems.mockResolvedValue([
+      {
+        metadata: {
+          name: 'hub-cluster',
+        },
+      },
+    ])
+
+    const result = await getFleetK8sAPIPath('managed-cluster-1')
+    expect(result).toBe('http://localhost:9000/api/clusters/managed-cluster-1')
+  })
+
+  it('should return managed cluster path when ManagedCluster CRD is not available (404 error)', async () => {
+    mockK8sListItems.mockRejectedValue({ code: 404 })
+
+    const result = await getFleetK8sAPIPath('managed-cluster-1')
+    expect(result).toBe('http://localhost:9000/api/clusters/managed-cluster-1')
+  })
+
+  it('should return managed cluster path when other errors occur', async () => {
+    mockK8sListItems.mockRejectedValue(new Error('Network error'))
+
+    const result = await getFleetK8sAPIPath('managed-cluster-1')
+    expect(result).toBe('http://localhost:9000/api/clusters/managed-cluster-1')
+  })
+
+  it('should return managed cluster path when hub cluster is not found', async () => {
+    mockK8sListItems.mockResolvedValue([])
+
+    const result = await getFleetK8sAPIPath('managed-cluster-1')
+    expect(result).toBe('http://localhost:9000/api/clusters/managed-cluster-1')
+  })
+})

frontend/packages/multicluster-sdk/src/components/index.test.ts

@@ -0,0 +1,9 @@
+/* Copyright Contributors to the Open Cluster Management project */
+import * as components from './index'
+
+describe('components index', () => {
+  it('should export FleetResourceEventStream', () => {
+    expect(components.FleetResourceEventStream).toBeDefined()
+    expect(typeof components.FleetResourceEventStream).toBe('function')
+  })
+})

frontend/packages/multicluster-sdk/src/internal/FleetResourceEventStream/EventComponent.test.tsx

@@ -33,7 +33,7 @@ jest.mock('react-router-dom-v5-compat', () => ({
 }))
 
 jest.mock('@openshift-console/dynamic-plugin-sdk', () => ({
-  useAccessReview: () => true,
+  useAccessReview: jest.fn(),
   ResourceLink: ({ kind, name }: { kind: string; name: string }) => (
     <span data-testid={`resource-link-${kind}-${name}`}>{name}</span>
   ),
@@ -120,4 +120,95 @@ describe('EventComponent', () => {
     expect(mockCache.clear).toHaveBeenCalledWith(0, 0)
     expect(mockList.recomputeRowHeights).toHaveBeenCalledWith(0)
   })
+
+  it('should handle different access review scenarios', () => {
+    const { useAccessReview } = jest.requireMock('@openshift-console/dynamic-plugin-sdk')
+
+    // Test with access allowed
+    useAccessReview.mockReturnValue(true)
+    const MockEventComponent = jest.fn().mockImplementation(({ cache, list, index }) => {
+      useEffect(() => {
+        cache.clear(index, 0)
+        list?.recomputeRowHeights(index)
+      }, [cache, list, index])
+      return null
+    })
+
+    render(<MockEventComponent event={mockEvent} cache={mockCache} list={mockList} index={0} />)
+
+    // Test with access denied
+    useAccessReview.mockReturnValue(false)
+    render(<MockEventComponent event={mockEvent} cache={mockCache} list={mockList} index={0} />)
+  })
+
+  it('should handle events with different component sources', () => {
+    const { useAccessReview } = jest.requireMock('@openshift-console/dynamic-plugin-sdk')
+    useAccessReview.mockReturnValue(true)
+
+    const eventWithDifferentSource = {
+      ...mockEvent,
+      source: {
+        component: 'scheduler',
+        host: 'node-2',
+      },
+      reportingComponent: 'scheduler',
+    }
+
+    const MockEventComponent = jest.fn().mockImplementation(({ cache, list, index }) => {
+      useEffect(() => {
+        cache.clear(index, 0)
+        list?.recomputeRowHeights(index)
+      }, [cache, list, index])
+      return null
+    })
+
+    render(<MockEventComponent event={eventWithDifferentSource} cache={mockCache} list={mockList} index={0} />)
+  })
+
+  it('should handle events with series data', () => {
+    const { useAccessReview } = jest.requireMock('@openshift-console/dynamic-plugin-sdk')
+    useAccessReview.mockReturnValue(true)
+
+    const eventWithSeries = {
+      ...mockEvent,
+      series: {
+        count: 5,
+        lastObservedTime: '2023-01-01T01:00:00Z',
+        state: 'active',
+      },
+    }
+
+    const MockEventComponent = jest.fn().mockImplementation(({ cache, list, index }) => {
+      useEffect(() => {
+        cache.clear(index, 0)
+        list?.recomputeRowHeights(index)
+      }, [cache, list, index])
+      return null
+    })
+
+    render(<MockEventComponent event={eventWithSeries} cache={mockCache} list={mockList} index={0} />)
+  })
+
+  it('should handle events without namespace', () => {
+    const { useAccessReview } = jest.requireMock('@openshift-console/dynamic-plugin-sdk')
+    useAccessReview.mockReturnValue(true)
+
+    const eventWithoutNamespace = {
+      ...mockEvent,
+      involvedObject: {
+        ...mockEvent.involvedObject,
+        namespace: undefined,
+      },
+    }
+
+    const MockEventComponent = jest.fn().mockImplementation(({ cache, list, index }) => {
+      useEffect(() => {
+        cache.clear(index, 0)
+        list?.recomputeRowHeights(index)
+      }, [cache, list, index])
+      return null
+    })
+
+    render(<MockEventComponent event={eventWithoutNamespace} cache={mockCache} list={mockList} index={0} />)
+  })
 })

frontend/packages/multicluster-sdk/src/internal/FleetResourceEventStream/constants.test.ts

@@ -0,0 +1,123 @@
+/* Copyright Contributors to the Open Cluster Management project */
+import { MAX_MESSAGES, EventInvolvedObject, EventKind } from './constants'
+
+describe('constants', () => {
+  describe('MAX_MESSAGES', () => {
+    it('should export MAX_MESSAGES constant', () => {
+      expect(MAX_MESSAGES).toBe(500)
+    })
+  })
+
+  describe('EventInvolvedObject type', () => {
+    it('should allow optional properties', () => {
+      const eventInvolvedObject: EventInvolvedObject = {
+        apiVersion: 'v1',
+        kind: 'Pod',
+        name: 'test-pod',
+        uid: '123',
+        namespace: 'default',
+      }
+
+      expect(eventInvolvedObject.apiVersion).toBe('v1')
+      expect(eventInvolvedObject.kind).toBe('Pod')
+      expect(eventInvolvedObject.name).toBe('test-pod')
+      expect(eventInvolvedObject.uid).toBe('123')
+      expect(eventInvolvedObject.namespace).toBe('default')
+    })
+
+    it('should allow partial properties', () => {
+      const eventInvolvedObject: EventInvolvedObject = {
+        kind: 'Pod',
+        name: 'test-pod',
+      }
+
+      expect(eventInvolvedObject.kind).toBe('Pod')
+      expect(eventInvolvedObject.name).toBe('test-pod')
+      expect(eventInvolvedObject.apiVersion).toBeUndefined()
+      expect(eventInvolvedObject.uid).toBeUndefined()
+      expect(eventInvolvedObject.namespace).toBeUndefined()
+    })
+  })
+
+  describe('EventKind type', () => {
+    it('should allow all optional properties', () => {
+      const eventKind: EventKind = {
+        reportingComponent: 'test-component',
+        action: 'test-action',
+        count: 5,
+        type: 'Normal',
+        involvedObject: {
+          kind: 'Pod',
+          name: 'test-pod',
+        },
+        message: 'Test message',
+        eventTime: '2023-01-01T00:00:00Z',
+        lastTimestamp: '2023-01-01T00:00:00Z',
+        firstTimestamp: '2023-01-01T00:00:00Z',
+        reason: 'TestReason',
+        source: {
+          component: 'test-source',
+          host: 'test-host',
+        },
+        series: {
+          count: 3,
+          lastObservedTime: '2023-01-01T00:00:00Z',
+          state: 'active',
+        },
+        apiVersion: 'v1',
+        kind: 'Event',
+        metadata: {
+          name: 'test-event',
+          uid: '123',
+        },
+      }
+
+      expect(eventKind.reportingComponent).toBe('test-component')
+      expect(eventKind.action).toBe('test-action')
+      expect(eventKind.count).toBe(5)
+      expect(eventKind.type).toBe('Normal')
+      expect(eventKind.message).toBe('Test message')
+      expect(eventKind.eventTime).toBe('2023-01-01T00:00:00Z')
+      expect(eventKind.lastTimestamp).toBe('2023-01-01T00:00:00Z')
+      expect(eventKind.firstTimestamp).toBe('2023-01-01T00:00:00Z')
+      expect(eventKind.reason).toBe('TestReason')
+      expect(eventKind.source.component).toBe('test-source')
+      expect(eventKind.source.host).toBe('test-host')
+      expect(eventKind.series?.count).toBe(3)
+      expect(eventKind.series?.lastObservedTime).toBe('2023-01-01T00:00:00Z')
+      expect(eventKind.series?.state).toBe('active')
+    })
+
+    it('should allow minimal required properties', () => {
+      const eventKind: EventKind = {
+        involvedObject: {
+          kind: 'Pod',
+          name: 'test-pod',
+        },
+        source: {
+          component: 'test-source',
+        },
+        apiVersion: 'v1',
+        kind: 'Event',
+        metadata: {
+          name: 'test-event',
+          uid: '123',
+        },
+      }
+
+      expect(eventKind.involvedObject.kind).toBe('Pod')
+      expect(eventKind.source.component).toBe('test-source')
+      expect(eventKind.reportingComponent).toBeUndefined()
+      expect(eventKind.action).toBeUndefined()
+      expect(eventKind.count).toBeUndefined()
+      expect(eventKind.type).toBeUndefined()
+      expect(eventKind.message).toBeUndefined()
+      expect(eventKind.eventTime).toBeUndefined()
+      expect(eventKind.lastTimestamp).toBeUndefined()
+      expect(eventKind.firstTimestamp).toBeUndefined()
+      expect(eventKind.reason).toBeUndefined()
+      expect(eventKind.source.host).toBeUndefined()
+      expect(eventKind.series).toBeUndefined()
+    })
+  })
+})