chore: import upstream snapshot with attribution

apps/sim/lib/execution/cancellation.test.ts

@@ -0,0 +1,125 @@
+import { redisConfigMock, redisConfigMockFns } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockRedisSet, mockPublish, mockSubscribe } = vi.hoisted(() => ({
+  mockRedisSet: vi.fn(),
+  mockPublish: vi.fn(),
+  mockSubscribe: vi.fn(),
+}))
+
+const mockGetRedisClient = redisConfigMockFns.mockGetRedisClient
+
+vi.mock('@/lib/core/config/redis', () => redisConfigMock)
+vi.mock('@/lib/events/pubsub', () => ({
+  createPubSubChannel: () => ({
+    publish: mockPublish,
+    subscribe: mockSubscribe,
+    dispose: vi.fn(),
+  }),
+}))
+
+import { getCancellationChannel, markExecutionCancelled } from './cancellation'
+import {
+  abortManualExecution,
+  registerManualExecutionAborter,
+  unregisterManualExecutionAborter,
+} from './manual-cancellation'
+
+describe('markExecutionCancelled', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns redis_unavailable when no Redis client exists', async () => {
+    mockGetRedisClient.mockReturnValue(null)
+
+    await expect(markExecutionCancelled('execution-1')).resolves.toEqual({
+      durablyRecorded: false,
+      reason: 'redis_unavailable',
+    })
+  })
+
+  it('returns recorded when Redis write succeeds', async () => {
+    mockRedisSet.mockResolvedValue('OK')
+    mockGetRedisClient.mockReturnValue({ set: mockRedisSet })
+
+    await expect(markExecutionCancelled('execution-1')).resolves.toEqual({
+      durablyRecorded: true,
+      reason: 'recorded',
+    })
+  })
+
+  it('returns redis_write_failed when Redis write throws', async () => {
+    mockRedisSet.mockRejectedValue(new Error('set failed'))
+    mockGetRedisClient.mockReturnValue({ set: mockRedisSet })
+
+    await expect(markExecutionCancelled('execution-1')).resolves.toEqual({
+      durablyRecorded: false,
+      reason: 'redis_write_failed',
+    })
+  })
+
+  it('publishes even when the Redis write fails so local subscribers wake up', async () => {
+    mockRedisSet.mockRejectedValue(new Error('set failed'))
+    mockGetRedisClient.mockReturnValue({ set: mockRedisSet })
+
+    await markExecutionCancelled('execution-write-failed')
+
+    expect(mockPublish).toHaveBeenCalledWith({ executionId: 'execution-write-failed' })
+  })
+
+  it('publishes a cancellation event after a successful Redis write', async () => {
+    mockRedisSet.mockResolvedValue('OK')
+    mockGetRedisClient.mockReturnValue({ set: mockRedisSet })
+
+    await markExecutionCancelled('execution-2')
+
+    expect(mockPublish).toHaveBeenCalledWith({ executionId: 'execution-2' })
+    expect(mockRedisSet.mock.invocationCallOrder[0]).toBeLessThan(
+      mockPublish.mock.invocationCallOrder[0]
+    )
+  })
+
+  it('publishes even when Redis is unavailable so local subscribers wake up', async () => {
+    mockGetRedisClient.mockReturnValue(null)
+
+    await markExecutionCancelled('execution-3')
+
+    expect(mockPublish).toHaveBeenCalledWith({ executionId: 'execution-3' })
+  })
+})
+
+describe('getCancellationChannel', () => {
+  it('returns the same channel instance across calls', () => {
+    expect(getCancellationChannel()).toBe(getCancellationChannel())
+  })
+})
+
+describe('manual execution cancellation registry', () => {
+  beforeEach(() => {
+    unregisterManualExecutionAborter('execution-1')
+  })
+
+  it('aborts registered executions', () => {
+    const abort = vi.fn()
+
+    registerManualExecutionAborter('execution-1', abort)
+
+    expect(abortManualExecution('execution-1')).toBe(true)
+    expect(abort).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns false when no execution is registered', () => {
+    expect(abortManualExecution('execution-missing')).toBe(false)
+  })
+
+  it('unregisters executions', () => {
+    const abort = vi.fn()
+
+    registerManualExecutionAborter('execution-1', abort)
+    unregisterManualExecutionAborter('execution-1')
+
+    expect(abortManualExecution('execution-1')).toBe(false)
+    expect(abort).not.toHaveBeenCalled()
+  })
+})