test(desktop): check delivered events and real requests, not mock calls

Author: waleedlatif1

apps/sim/hooks/queries/desktop-activity.test.tsx

@@ -1,17 +1,20 @@
 /** @vitest-environment jsdom */
 
 import { act } from 'react'
-import {
-  apiClientRequestMock,
-  apiClientRequestMockFns,
-} from '@sim/testing/mocks/api-client-request.mock'
+import { jsonResponse } from '@sim/testing/helpers/http'
+import { setupGlobalFetchMock } from '@sim/testing/mocks/fetch.mock'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-vi.mock('@/lib/api/client/request', () => apiClientRequestMock)
+/** The page's real requests land on this fetch, installed fresh for each test. */
+let fetchMock = setupGlobalFetchMock()
 
-const requestJson = apiClientRequestMockFns.mockRequestJson
+/** Requests the page sent for desktop activity. */
+function activityRequests(): number {
+  return fetchMock.mock.calls.filter(([input]) => String(input).includes('/api/desktop/activity'))
+    .length
+}
 
 import { useDesktopActivity, watchesDesktopActivity } from '@/hooks/queries/desktop-activity'
 
@@ -53,8 +56,8 @@ describe('desktop activity polling', () => {
   beforeEach(() => {
     vi.useFakeTimers()
     vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
-    requestJson.mockReset()
-    requestJson.mockResolvedValue({ chats: [] })
+    fetchMock = setupGlobalFetchMock()
+    fetchMock.mockImplementation(async () => jsonResponse({ chats: [] }))
   })
 
   afterEach(() => {
@@ -66,8 +69,10 @@ describe('desktop activity polling', () => {
   })
 
   it('shows nothing once the page stops watching, though the query kept its last result', async () => {
-    const activity = [{ chatId: 'chat-1' }]
-    requestJson.mockResolvedValueOnce({ chats: activity })
+    const activity = [
+      { chatId: 'chat-1', streamId: 'stream-1', state: 'running', deviceName: 'Work laptop' },
+    ]
+    fetchMock.mockImplementationOnce(async () => jsonResponse({ chats: activity }))
     const container = document.createElement('div')
     document.body.appendChild(container)
     root = createRoot(container)
@@ -95,21 +100,21 @@ describe('desktop activity polling', () => {
     await mount(false)
     await waitTwoMinutes()
 
-    expect(requestJson).not.toHaveBeenCalled()
+    expect(activityRequests()).toBe(0)
   })
 
   it('polls for a user with a registered desktop', async () => {
     await mount(true)
     await waitTwoMinutes()
 
-    expect(requestJson.mock.calls.length).toBeGreaterThanOrEqual(4)
+    expect(activityRequests()).toBeGreaterThanOrEqual(4)
   })
 
   it('polls in the desktop app before its first registration reaches the page', async () => {
     Object.defineProperty(window, 'simDesktop', { value: {}, configurable: true })
     await mount(false)
     await waitTwoMinutes()
 
-    expect(requestJson.mock.calls.length).toBeGreaterThanOrEqual(4)
+    expect(activityRequests()).toBeGreaterThanOrEqual(4)
   })
 })

apps/sim/hooks/use-mothership-chat-events.test.ts

@@ -395,12 +395,6 @@ describe('reflectBackgroundChatStatus', () => {
     "leaves the desktop activity alone when a teammate's turn has %s",
     (type) => {
       showing('/workspace/ws-1/home', false)
-      const fetchActivity = vi.fn(async () => [])
-      const unsubscribe = new QueryObserver(queryClient, {
-        queryKey: desktopActivityKeys.list('ws-1'),
-        queryFn: fetchActivity,
-        staleTime: Number.POSITIVE_INFINITY,
-      }).subscribe(() => {})
 
       reflectBackgroundChatStatus(
         queryClient,
@@ -410,8 +404,6 @@ describe('reflectBackgroundChatStatus', () => {
       )
 
       expect(activityStale()).toBe(false)
-      expect(fetchActivity).not.toHaveBeenCalled()
-      unsubscribe()
     }
   )
 

apps/sim/lib/mothership/chat-status.test.ts

@@ -1,33 +1,35 @@
-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import {
+  type ChatStatusEvent,
+  chatPubSub,
+  publishChatStatusChanged,
+} from '@/lib/mothership/chat-status'
 
-const { publish } = vi.hoisted(() => ({ publish: vi.fn() }))
-vi.mock('@/lib/events/pubsub', () => ({
-  createPubSubChannel: () => ({ publish, subscribe: vi.fn(), dispose: vi.fn() }),
-}))
+/** Events as a subscriber receives them from the channel (process-local without Redis). */
+let received: ChatStatusEvent[] = []
+let unsubscribe: () => void = () => {}
 
-import { publishChatStatusChanged } from '@/lib/mothership/chat-status'
+beforeEach(() => {
+  received = []
+  unsubscribe = chatPubSub?.onStatusChanged((event) => received.push(event)) ?? (() => {})
+})
+
+afterEach(() => unsubscribe())
 
 describe('chat status ownership', () => {
   it('names the chat owner on workspace events, so each member can tell their own chats', () => {
     publishChatStatusChanged(
       { workspaceId: 'ws-1', userId: 'user-1' },
       { chatId: 'chat-1', type: 'renamed' }
     )
-    expect(publish).toHaveBeenCalledWith({
-      workspaceId: 'ws-1',
-      userId: 'user-1',
-      chatId: 'chat-1',
-      type: 'renamed',
-    })
+    expect(received).toEqual([
+      { workspaceId: 'ws-1', userId: 'user-1', chatId: 'chat-1', type: 'renamed' },
+    ])
   })
 
   it('publishes a workspace event without an owner when the publisher does not know it', () => {
     publishChatStatusChanged({ workspaceId: 'ws-1' }, { chatId: 'chat-1', type: 'renamed' })
-    expect(publish).toHaveBeenLastCalledWith({
-      workspaceId: 'ws-1',
-      chatId: 'chat-1',
-      type: 'renamed',
-    })
+    expect(received).toEqual([{ workspaceId: 'ws-1', chatId: 'chat-1', type: 'renamed' }])
   })
 
   it.each(['completed'] as const)(
@@ -37,20 +39,17 @@ describe('chat status ownership', () => {
         { organizationId: 'org-1', userId: 'user-1' },
         { chatId: 'chat-1', type }
       )
-      expect(publish).toHaveBeenCalledWith({
-        organizationId: 'org-1',
-        userId: 'user-1',
-        chatId: 'chat-1',
-        type,
-      })
+      expect(received).toEqual([
+        { organizationId: 'org-1', userId: 'user-1', chatId: 'chat-1', type },
+      ])
     }
   )
 
   it('does not broadcast an organization event without its private owner', () => {
     expect(() =>
       publishChatStatusChanged({ organizationId: 'org-1' }, { chatId: 'chat-1', type: 'created' })
     ).toThrow('Invalid organization chat owner')
-    expect(publish).not.toHaveBeenCalled()
+    expect(received).toEqual([])
   })
 
   it('refuses ambiguous workspace and organization ownership', () => {
@@ -60,6 +59,6 @@ describe('chat status ownership', () => {
         { chatId: 'chat-1', type: 'created' }
       )
     ).toThrow('Invalid organization chat owner')
-    expect(publish).not.toHaveBeenCalled()
+    expect(received).toEqual([])
   })
 })