test(dashboards): drop mock-call and rendered-text assertions

Removes assertions on mocked collaborators and rendered text from the
dashboard, chart and analytics tests per the repository testing rules, keeping
the observable checks (status codes, thrown errors, DOM roles, computed
summaries, emitted zoom ranges). Deletes the animated-number test, which had
no behavior left to assert.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S6aTRnkiu7PxYZPNPXYEMV

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/analytics/route.test.ts

@@ -44,25 +44,16 @@ describe('analytics HTTP adapter', () => {
   it('authenticates before parsing and never uses a file share as authority', async () => {
     mocks.session.mockResolvedValue(null)
     expect((await POST(request({ invalid: true }), context)).status).toBe(401)
-    expect(mocks.execute).not.toHaveBeenCalled()
   })
   it('validates the contract before the use case', async () => {
     expect(
       (await POST(request({ ...body, query: { ...body.query, sql: 'select *' } }), context)).status
     ).toBe(400)
-    expect(mocks.execute).not.toHaveBeenCalled()
   })
-  it('forwards the viewer and asserted scope and emits a private response', async () => {
+  it('emits a private response', async () => {
     const response = await POST(request(body), context)
     expect(response.status).toBe(200)
     expect(response.headers.get('cache-control')).toBe('private, no-store')
     expect(await response.json()).toMatchObject({ rows: [{ n: 0 }], truncated: false })
-    expect(mocks.execute).toHaveBeenCalledWith(
-      expect.objectContaining({
-        principal: { kind: 'session', userId: 'viewer', sessionId: 'session' },
-        input: { tableId: 'tbl_test', assertedWorkspaceId: 'workspace_test', query: body.query },
-      })
-    )
-    expect(mocks.limit).toHaveBeenCalledWith('table-analytics', 'viewer', expect.any(Object))
   })
 })

apps/sim/components/charts/echarts-view.test.tsx

@@ -69,7 +69,7 @@ describe('EChartsView updates', () => {
       throw new Error('Invalid chart option')
     })
     await render(12)
-    expect(container.querySelector('[role="alert"]')?.textContent).toBe('Invalid chart option')
+    expect(container.querySelector('[role="alert"]')).not.toBeNull()
     await render(6)
     expect(container.querySelector('[role="alert"]')).toBeNull()
   })

apps/sim/components/dashboards/dashboard-panel.test.tsx

@@ -68,9 +68,7 @@ describe('dashboard empty-range transitions', () => {
     expect(chart).not.toBeNull()
     await render([])
     expect(container.querySelector('[role="img"]')).toBe(chart)
-    expect(container.textContent).toContain('No data in this time range')
     await render([{ total: 12 }])
     expect(container.querySelector('[role="img"]')).toBe(chart)
-    expect(container.textContent).not.toContain('No data in this time range')
   })
 })

apps/sim/lib/charts/summary.test.ts

@@ -1,6 +1,6 @@
 /** @vitest-environment jsdom */
 import * as echarts from 'echarts'
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import {
   chartSummaryExtension,
   formatChartValue,
@@ -74,8 +74,10 @@ describe('resolved chart summaries', () => {
 
   it('keeps missing data distinct from actual zero and excludes hidden legend series', () => {
     const chart = makeChart()
-    const read = vi.fn()
-    const stop = observeChartSummary(chart, (model) => read(summarizeChart(model, {})))
+    let summary: ChartReadout | null = null
+    const stop = observeChartSummary(chart, (model) => {
+      summary = summarizeChart(model, {})
+    })
     chart.setOption({
       animation: false,
       legend: { selected: { Hidden: false } },
@@ -94,32 +96,28 @@ describe('resolved chart summaries', () => {
         { name: 'Hidden', type: 'line', data: [['2026-09-20', 100]] },
       ],
     })
-    expect(
-      read.mock.lastCall![0].values.map(({ name, value }: { name: string; value: string }) => ({
-        name,
-        value,
-      }))
-    ).toEqual([
-      { name: 'Zero', value: '0%' },
-      { name: 'Missing', value: '—' },
-    ])
+    expect(summary).toMatchObject({
+      values: [
+        { name: 'Zero', value: '0%' },
+        { name: 'Missing', value: '—' },
+      ],
+    })
     stop()
-    read.mockClear()
-    chart.resize({ width: 700 })
-    expect(read).not.toHaveBeenCalled()
     chart.dispose()
   })
 
   it('restores a summary after hover and recomputes it on new data', () => {
     const chart = makeChart()
-    const onReadout = vi.fn()
+    let readout: ChartReadout | null = null
     const controller = bindTimeSeriesInteractions(chart, {
       range: { from: '2026-09-20T00:00:00Z', to: '2026-09-22T00:00:00Z' },
       firstTime: Date.parse('2026-09-20'),
       timeZone: 'UTC',
       columnLabels: {},
       cursorStore: createDashboardCursorStore(),
-      onReadout,
+      onReadout: (next) => {
+        readout = next
+      },
     })
     const option = (value: number) =>
       controller.prepareOption({
@@ -139,16 +137,16 @@ describe('resolved chart summaries', () => {
       })
     chart.setOption(option(2))
     controller.afterUpdate()
-    expect(onReadout.mock.lastCall![0]).toMatchObject({
+    expect(readout).toMatchObject({
       time: null,
       values: [{ value: '5', summary: 'Total' }],
     })
     chart.dispatchAction({ type: 'showTip', seriesIndex: 0, dataIndex: 0 })
     chart.dispatchAction({ type: 'hideTip' })
-    expect(onReadout.mock.lastCall![0].values[0].value).toBe('5')
+    expect(readout).toMatchObject({ values: [{ value: '5' }] })
     chart.setOption(option(7), { notMerge: true })
     controller.afterUpdate()
-    expect(onReadout.mock.lastCall![0].values[0].value).toBe('10')
+    expect(readout).toMatchObject({ values: [{ value: '10' }] })
     controller.dispose()
     chart.dispose()
   })

apps/sim/lib/charts/time-series.test.ts

@@ -84,14 +84,13 @@ describe('time chart interactions', () => {
   it('shows timestamp and decimal values only in the hovered chart tooltip', () => {
     const { instance } = makeChart('one')
     const store = createDashboardCursorStore()
-    const onReadout = vi.fn()
     const controller = bindTimeSeriesInteractions(instance, {
       range,
       timeZone: 'America/Los_Angeles',
       cursorStore: store,
       columnLabels: {},
       firstTime: time,
-      onReadout,
+      onReadout: () => {},
     })
     const option = controller.prepareOption({
       xAxis: { type: 'time' },
@@ -113,11 +112,10 @@ describe('time chart interactions', () => {
     expect(tooltip.formatter(params)).toBe('Sep 20, 17:00 PDT\nResolved: 71.63%')
     store.getState().setCursor({ owner: 'other', group: `${range.from}/${range.to}`, time })
     expect(tooltip.formatter(params)).toBe('')
-    expect(onReadout).toHaveBeenLastCalledWith(expect.objectContaining({ time }))
     controller.dispose()
     expect(tooltip.formatter(params)).toBe('')
   })
-  it('synchronizes by timestamp without feedback loops, isolates other ranges, and cleans up', () => {
+  it('shares the hovered timestamp through the cursor store and clears it on leave', () => {
     const store = createDashboardCursorStore()
     const first = makeChart('one')
     const second = makeChart('two')
@@ -128,7 +126,7 @@ describe('time chart interactions', () => {
       cursorStore: store,
       columnLabels: {},
       firstTime: time,
-      onReadout: vi.fn(),
+      onReadout: () => {},
     }
     const bindings = [
       bindTimeSeriesInteractions(first.instance, config),
@@ -140,44 +138,27 @@ describe('time chart interactions', () => {
     ]
     first.handlers.get('updateAxisPointer')?.({ axesInfo: [{ axisDim: 'x', value: time }] })
     expect(store.getState().cursor?.owner).toBe('one')
-    expect(second.chart.dispatchAction).toHaveBeenCalledTimes(1)
-    expect(second.chart.dispatchAction).toHaveBeenCalledWith({
-      type: 'updateAxisPointer',
-      x: time / 10000,
-      y: 110,
-    })
-    expect(third.chart.dispatchAction).not.toHaveBeenCalledWith(
-      expect.objectContaining({ x: time / 10000, type: 'updateAxisPointer' })
-    )
     first.handlers.get('hideTip')?.({})
     expect(store.getState().cursor).toBeNull()
     bindings.forEach((binding) => binding.dispose())
-    expect(second.handlers.size).toBe(0)
-    second.chart.dispatchAction.mockClear()
-    store.getState().setCursor({ owner: 'other', group: `${range.from}/${range.to}`, time })
-    expect(second.chart.dispatchAction).not.toHaveBeenCalled()
   })
-  it('queries only after a meaningful completed brush, clears it, and ignores clicks', () => {
-    const { instance, handlers, chart } = makeChart('one')
-    const onZoom = vi.fn()
+  it('zooms only after a meaningful completed brush and ignores clicks', () => {
+    const { instance, handlers } = makeChart('one')
+    const zooms: unknown[] = []
     const controller = bindTimeSeriesInteractions(instance, {
       range,
       timeZone: 'UTC',
       cursorStore: createDashboardCursorStore(),
       columnLabels: {},
       firstTime: time,
-      onReadout: vi.fn(),
-      onZoom,
+      onReadout: () => {},
+      onZoom: (zoom) => zooms.push(zoom),
     })
     expect(handlers.has('brush')).toBe(false)
     handlers.get('brushEnd')?.({ areas: [{ coordRange: [time, time + 3600000], range: [30, 31] }] })
-    expect(onZoom).not.toHaveBeenCalled()
+    expect(zooms).toEqual([])
     handlers.get('brushEnd')?.({ areas: [{ coordRange: [time + 3600000, time], range: [80, 30] }] })
-    expect(onZoom).toHaveBeenCalledExactlyOnceWith({
-      from: '2026-09-21T00:00:00.000Z',
-      to: '2026-09-21T01:00:00.000Z',
-    })
-    expect(chart.dispatchAction).toHaveBeenCalledWith({ type: 'brush', areas: [] })
+    expect(zooms).toEqual([{ from: '2026-09-21T00:00:00.000Z', to: '2026-09-21T01:00:00.000Z' }])
     controller.dispose()
   })
 })

apps/sim/lib/skills/application/use-cases.test.ts

@@ -79,7 +79,6 @@ describe('skill application use cases', () => {
         input: { workspaceId: workspace.workspaceId, skillId: 'builtin-create-dashboard' },
       })
     ).rejects.toThrow('Dashboards are not enabled')
-    expect(mocks.flag).toHaveBeenCalledWith(null)
   })
 
   it.each(['skill-1', 'builtin-research'])(

apps/sim/lib/table/analytics/query.test.ts

@@ -97,10 +97,6 @@ describe('table analytics SQL', () => {
       })
     )
     expect(result.rows).toEqual([{ total: 0, sum: null }])
-    expect(guards).toHaveBeenCalledWith(expect.any(Function), {
-      seqscanOff: true,
-      repeatableRead: true,
-    })
   })
   it('fails on overflow or oversized output and marks top-N', async () => {
     execute.mockResolvedValue(

apps/sim/lib/table/application/analytics.test.ts

@@ -63,37 +63,17 @@ beforeEach(() => {
   })
 })
 describe('authorized table analytics', () => {
-  it('checks dashboard rollout against the canonical organization before querying', async () => {
+  it('rejects when dashboards are not enabled for the organization', async () => {
     mocks.flag.mockRejectedValue(new Error('Dashboards are not enabled'))
     await expect(readTableAnalytics.execute({ principal, input })).rejects.toThrow(
       'Dashboards are not enabled'
     )
-    expect(mocks.flag).toHaveBeenCalledWith('org_test')
-    expect(mocks.query).not.toHaveBeenCalled()
   })
 
-  it('authorizes the current viewer and passes canonical scope to the repository', async () => {
+  it('returns analytics for an authorized viewer', async () => {
     expect(await readTableAnalytics.execute({ principal, input })).toHaveProperty('rows.0.n', 4)
-    expect(mocks.permission).toHaveBeenCalledWith(
-      'viewer',
-      'workspace_test',
-      'org_test',
-      undefined,
-      expect.any(Object)
-    )
-    expect(mocks.capability).toHaveBeenCalledWith(
-      'viewer',
-      'workspace_test',
-      'tables.use',
-      'org_test',
-      undefined
-    )
-    expect(mocks.query.mock.calls[0][0]).toMatchObject({
-      id: 'tbl_test',
-      workspaceId: 'workspace_test',
-    })
   })
-  it('rejects API keys and delegation before loading protected data', async () => {
+  it('rejects API keys', async () => {
     await expect(
       readTableAnalytics.execute({
         principal: { kind: 'workspace_api_key', workspaceId: 'workspace_test', keyId: 'key' },
@@ -106,23 +86,20 @@ describe('authorized table analytics', () => {
         input,
       })
     ).rejects.toThrow()
-    expect(mocks.table).not.toHaveBeenCalled()
   })
   it('conceals a table in another workspace and missing/archived tables', async () => {
     mocks.table.mockResolvedValueOnce({ id: 'tbl_test', workspaceId: 'other' })
     await expect(readTableAnalytics.execute({ principal, input })).rejects.toThrow('not found')
     mocks.table.mockResolvedValueOnce(null)
     await expect(readTableAnalytics.execute({ principal, input })).rejects.toThrow('not found')
-    expect(mocks.query).not.toHaveBeenCalled()
   })
-  it('rechecks membership and capability before querying', async () => {
+  it('rejects without membership or the tables capability', async () => {
     mocks.permission.mockResolvedValueOnce(null)
     await expect(readTableAnalytics.execute({ principal, input })).rejects.toThrow('Insufficient')
     mocks.capability.mockRejectedValueOnce(new Error('Tables disabled'))
     await expect(readTableAnalytics.execute({ principal, input })).rejects.toThrow(
       'Tables disabled'
     )
-    expect(mocks.query).not.toHaveBeenCalled()
   })
   it('rejects invalid domain input and propagates infrastructure errors', async () => {
     await expect(