Add more coverage

Author: daniel-slaugh

apps/data-management/src/api/__tests__/api.spec.ts

@@ -5,6 +5,12 @@ const { fetchMock } = vi.hoisted(() => ({
 }))
 
 vi.mock('@hydroserver/client', () => {
+  const defaultExport = {
+    session: {
+      getAccessToken: vi.fn().mockResolvedValue(null),
+    },
+  }
+
   class Thing {
     id = ''
     workspaceId = ''
@@ -35,6 +41,7 @@ vi.mock('@hydroserver/client', () => {
   }
 
   return {
+    default: defaultExport,
     Thing,
     Datastream,
     ObservedProperty,

apps/data-management/src/api/thingMarkers.ts

@@ -7,6 +7,7 @@ const apiBaseUrl = import.meta.env.VITE_APP_PROXY_BASE_URL || apiHost
 export async function listThingMarkers(): Promise<ThingMarker[]> {
   const accessToken = await hs.session.getAccessToken()
   const response = await fetch(`${apiBaseUrl}/api/data/things/markers`, {
+    credentials: 'include',
     headers: {
       Accept: 'application/json',
       ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),

apps/data-management/src/api/thingSiteSummaries.ts

@@ -12,6 +12,7 @@ export async function listThingSiteSummaries(
   const response = await fetch(
     `${apiBaseUrl}/api/data/things/site-summaries?${query.toString()}`,
     {
+      credentials: 'include',
       headers: {
         Accept: 'application/json',
         ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),

apps/data-management/src/api/visualizationBootstrap.ts

@@ -53,6 +53,7 @@ export async function getVisualizationBootstrap() {
   const response = await fetch(
     `${apiBaseUrl}/api/data/datastreams/visualization-bootstrap`,
     {
+      credentials: 'include',
       headers: {
         Accept: 'application/json',
         ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),

apps/data-management/src/bootstrap/__tests__/appInitialization.spec.ts

@@ -223,4 +223,178 @@ describe('app initialization bootstrap', () => {
 
     consoleErrorSpy.mockRestore()
   })
+
+  it('returns an already resolved wait promise before initialization starts', async () => {
+    const { waitForHydroServerInitialization } = await import('../appInitialization')
+
+    await expect(waitForHydroServerInitialization()).resolves.toBeUndefined()
+  })
+
+  it('resets the user when the authenticated user request returns 401', async () => {
+    sessionState.isAuthenticated = true
+    sessionState.hasAccessToken = true
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockResolvedValue(undefined)
+    userGetMock.mockResolvedValue({
+      status: 401,
+      data: { email: 'ignored@example.com' },
+    })
+    listAllItemsMock.mockResolvedValue([
+      { id: 'workspace-1', name: 'Workspace 1' },
+    ])
+
+    const { startAppInitialization } = await import('../appInitialization')
+
+    await startAppInitialization()
+
+    const userStore = useUserStore()
+    expect(userStore.user.email).toBe('')
+  })
+
+  it('records user fetch failures without breaking workspace bootstrap', async () => {
+    const userError = new Error('user request failed')
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined)
+
+    sessionState.isAuthenticated = true
+    sessionState.hasAccessToken = true
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockResolvedValue(undefined)
+    userGetMock.mockRejectedValue(userError)
+    listAllItemsMock.mockResolvedValue([
+      { id: 'workspace-1', name: 'Workspace 1' },
+    ])
+
+    const {
+      hasBootstrappedWorkspaces,
+      initializationError,
+      startAppInitialization,
+    } = await import('../appInitialization')
+
+    await startAppInitialization()
+
+    expect(initializationError.value).toBe(userError)
+    expect(hasBootstrappedWorkspaces.value).toBe(true)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error fetching user',
+      userError
+    )
+
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('records workspace fetch failures without breaking user bootstrap', async () => {
+    const workspaceError = new Error('workspace request failed')
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined)
+
+    sessionState.isAuthenticated = true
+    sessionState.hasAccessToken = true
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockResolvedValue(undefined)
+    userGetMock.mockResolvedValue({
+      status: 200,
+      data: { email: 'user@example.com' },
+    })
+    listAllItemsMock.mockRejectedValue(workspaceError)
+
+    const {
+      hasBootstrappedWorkspaces,
+      initializationError,
+      startAppInitialization,
+    } = await import('../appInitialization')
+
+    await startAppInitialization()
+
+    const userStore = useUserStore()
+    expect(userStore.user.email).toBe('user@example.com')
+    expect(hasBootstrappedWorkspaces.value).toBe(false)
+    expect(initializationError.value).toBe(workspaceError)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error fetching workspaces',
+      workspaceError
+    )
+
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('records vocabulary fetch failures', async () => {
+    const vocabularyError = new Error('vocabulary request failed')
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined)
+
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockRejectedValue(vocabularyError)
+
+    const { initializationError, startAppInitialization } = await import(
+      '../appInitialization'
+    )
+
+    await startAppInitialization()
+
+    expect(initializationError.value).toBe(vocabularyError)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error fetching vocabularies',
+      vocabularyError
+    )
+
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('reuses the initialization promise and only attaches session listeners once', async () => {
+    sessionState.isAuthenticated = false
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockResolvedValue(undefined)
+
+    const { startAppInitialization } = await import('../appInitialization')
+
+    const first = startAppInitialization()
+    const second = startAppInitialization()
+
+    await first
+    await second
+
+    expect(first).toBe(second)
+    expect(createHydroServerMock).toHaveBeenCalledTimes(1)
+    expect(onMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('refreshes authenticated state when session change and expiry callbacks fire', async () => {
+    sessionState.isAuthenticated = true
+    sessionState.hasAccessToken = true
+    createHydroServerMock.mockResolvedValue(undefined)
+    fetchAllVocabulariesMock.mockResolvedValue(undefined)
+    userGetMock.mockResolvedValue({
+      status: 200,
+      data: { email: 'callback@example.com' },
+    })
+    listAllItemsMock.mockResolvedValue([
+      { id: 'workspace-1', name: 'Workspace 1' },
+    ])
+
+    const { startAppInitialization } = await import('../appInitialization')
+
+    await startAppInitialization()
+
+    const sessionChanged = onMock.mock.calls.find(
+      ([eventName]) => eventName === 'session:changed'
+    )?.[1] as (() => void) | undefined
+    const sessionExpired = onMock.mock.calls.find(
+      ([eventName]) => eventName === 'session:expired'
+    )?.[1] as (() => void) | undefined
+
+    expect(sessionChanged).toBeTypeOf('function')
+    expect(sessionExpired).toBeTypeOf('function')
+
+    sessionChanged?.()
+    sessionExpired?.()
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(userGetMock).toHaveBeenCalledTimes(3)
+    expect(listAllItemsMock).toHaveBeenCalledTimes(3)
+  })
 })

apps/data-management/src/composables/__tests__/useTableLogic.spec.ts

@@ -158,4 +158,47 @@ describe('useTableLogic', () => {
     expect(consoleErrorSpy).toHaveBeenCalled()
     consoleErrorSpy.mockRestore()
   })
+
+  it('does nothing when deleting with no selected item', async () => {
+    const apiDeleteFunction = vi.fn().mockResolvedValue(undefined)
+    const wrapper = mount(createDummyComponent({ apiDeleteFunction }))
+    await flushPromises()
+
+    const vm = wrapper.vm as Omit<typeof wrapper.vm, 'item'> & {
+      item: Unit | null
+    }
+    vm.item = null
+    await wrapper.vm.onDelete()
+
+    expect(apiDeleteFunction).not.toHaveBeenCalled()
+  })
+
+  it('reloads items when the workspace id changes', async () => {
+    const secondResult = [{ ...unitFixtures[0], id: 'reloaded-id' }]
+    const apiFetchFunction = vi
+      .fn()
+      .mockResolvedValueOnce(unitFixtures)
+      .mockResolvedValueOnce(secondResult)
+
+    const wrapper = mount(createDummyComponent({ apiFetchFunction }))
+    await flushPromises()
+
+    wrapper.vm.workspaceIdRef = 'next-workspace'
+    await flushPromises()
+
+    expect(apiFetchFunction).toHaveBeenCalledTimes(2)
+    expect(apiFetchFunction).toHaveBeenNthCalledWith(2, 'next-workspace')
+    expect(wrapper.vm.items).toEqual(secondResult)
+  })
+
+  it('does not reload items when the workspace id is set to the same value', async () => {
+    const apiFetchFunction = vi.fn().mockResolvedValue(unitFixtures)
+    const wrapper = mount(createDummyComponent({ apiFetchFunction }))
+    await flushPromises()
+
+    wrapper.vm.workspaceIdRef = 'test-workspace'
+    await flushPromises()
+
+    expect(apiFetchFunction).toHaveBeenCalledTimes(1)
+  })
 })