test(hitl): update cancel route tests for paused execution cancellation

- Mock PauseResumeManager.cancelPausedExecution to prevent DB calls
- Add pausedCancelled to all expected response objects
- Add test for HITL paused execution cancellation path
- Add missing auth/authz tests
- Switch to vi.hoisted pattern for all mocks

Author: waleedlatif1

apps/sim/app/api/workflows/[id]/executions/[executionId]/cancel/route.test.ts

@@ -5,13 +5,18 @@
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const mockCheckHybridAuth = vi.fn()
-const mockAuthorizeWorkflowByWorkspacePermission = vi.fn()
-const mockMarkExecutionCancelled = vi.fn()
-const mockAbortManualExecution = vi.fn()
-
-vi.mock('@sim/logger', () => ({
-  createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }),
+const {
+  mockCheckHybridAuth,
+  mockAuthorizeWorkflowByWorkspacePermission,
+  mockMarkExecutionCancelled,
+  mockAbortManualExecution,
+  mockCancelPausedExecution,
+} = vi.hoisted(() => ({
+  mockCheckHybridAuth: vi.fn(),
+  mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
+  mockMarkExecutionCancelled: vi.fn(),
+  mockAbortManualExecution: vi.fn(),
+  mockCancelPausedExecution: vi.fn(),
 }))
 
 vi.mock('@/lib/auth/hybrid', () => ({
@@ -26,19 +31,37 @@ vi.mock('@/lib/execution/manual-cancellation', () => ({
   abortManualExecution: (...args: unknown[]) => mockAbortManualExecution(...args),
 }))
 
+vi.mock('@/lib/workflows/executor/human-in-the-loop-manager', () => ({
+  PauseResumeManager: {
+    cancelPausedExecution: (...args: unknown[]) => mockCancelPausedExecution(...args),
+  },
+}))
+
 vi.mock('@/lib/workflows/utils', () => ({
   authorizeWorkflowByWorkspacePermission: (params: unknown) =>
     mockAuthorizeWorkflowByWorkspacePermission(params),
 }))
 
+vi.mock('@/lib/posthog/server', () => ({
+  captureServerEvent: vi.fn(),
+}))
+
 import { POST } from './route'
 
+const makeRequest = () =>
+  new NextRequest('http://localhost/api/workflows/wf-1/executions/ex-1/cancel', {
+    method: 'POST',
+  })
+
+const makeParams = () => ({ params: Promise.resolve({ id: 'wf-1', executionId: 'ex-1' }) })
+
 describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockCheckHybridAuth.mockResolvedValue({ success: true, userId: 'user-1' })
     mockAuthorizeWorkflowByWorkspacePermission.mockResolvedValue({ allowed: true })
     mockAbortManualExecution.mockReturnValue(false)
+    mockCancelPausedExecution.mockResolvedValue(false)
   })
 
   it('returns success when cancellation was durably recorded', async () => {
@@ -47,14 +70,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       reason: 'recorded',
     })
 
-    const response = await POST(
-      new NextRequest('http://localhost/api/workflows/wf-1/executions/ex-1/cancel', {
-        method: 'POST',
-      }),
-      {
-        params: Promise.resolve({ id: 'wf-1', executionId: 'ex-1' }),
-      }
-    )
+    const response = await POST(makeRequest(), makeParams())
 
     expect(response.status).toBe(200)
     await expect(response.json()).resolves.toEqual({
@@ -63,6 +79,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       redisAvailable: true,
       durablyRecorded: true,
       locallyAborted: false,
+      pausedCancelled: false,
       reason: 'recorded',
     })
   })
@@ -73,14 +90,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       reason: 'redis_unavailable',
     })
 
-    const response = await POST(
-      new NextRequest('http://localhost/api/workflows/wf-1/executions/ex-1/cancel', {
-        method: 'POST',
-      }),
-      {
-        params: Promise.resolve({ id: 'wf-1', executionId: 'ex-1' }),
-      }
-    )
+    const response = await POST(makeRequest(), makeParams())
 
     expect(response.status).toBe(200)
     await expect(response.json()).resolves.toEqual({
@@ -89,6 +99,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       redisAvailable: false,
       durablyRecorded: false,
       locallyAborted: false,
+      pausedCancelled: false,
       reason: 'redis_unavailable',
     })
   })
@@ -99,14 +110,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       reason: 'redis_write_failed',
     })
 
-    const response = await POST(
-      new NextRequest('http://localhost/api/workflows/wf-1/executions/ex-1/cancel', {
-        method: 'POST',
-      }),
-      {
-        params: Promise.resolve({ id: 'wf-1', executionId: 'ex-1' }),
-      }
-    )
+    const response = await POST(makeRequest(), makeParams())
 
     expect(response.status).toBe(200)
     await expect(response.json()).resolves.toEqual({
@@ -115,6 +119,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       redisAvailable: true,
       durablyRecorded: false,
       locallyAborted: false,
+      pausedCancelled: false,
       reason: 'redis_write_failed',
     })
   })
@@ -126,14 +131,7 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
     })
     mockAbortManualExecution.mockReturnValue(true)
 
-    const response = await POST(
-      new NextRequest('http://localhost/api/workflows/wf-1/executions/ex-1/cancel', {
-        method: 'POST',
-      }),
-      {
-        params: Promise.resolve({ id: 'wf-1', executionId: 'ex-1' }),
-      }
-    )
+    const response = await POST(makeRequest(), makeParams())
 
     expect(response.status).toBe(200)
     await expect(response.json()).resolves.toEqual({
@@ -142,7 +140,50 @@ describe('POST /api/workflows/[id]/executions/[executionId]/cancel', () => {
       redisAvailable: false,
       durablyRecorded: false,
       locallyAborted: true,
+      pausedCancelled: false,
+      reason: 'redis_unavailable',
+    })
+  })
+
+  it('returns success when a paused HITL execution is cancelled directly in the database', async () => {
+    mockMarkExecutionCancelled.mockResolvedValue({
+      durablyRecorded: false,
+      reason: 'redis_unavailable',
+    })
+    mockCancelPausedExecution.mockResolvedValue(true)
+
+    const response = await POST(makeRequest(), makeParams())
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      success: true,
+      executionId: 'ex-1',
+      redisAvailable: false,
+      durablyRecorded: false,
+      locallyAborted: false,
+      pausedCancelled: true,
       reason: 'redis_unavailable',
     })
   })
+
+  it('returns 401 when auth fails', async () => {
+    mockCheckHybridAuth.mockResolvedValue({ success: false, error: 'Unauthorized' })
+
+    const response = await POST(makeRequest(), makeParams())
+
+    expect(response.status).toBe(401)
+  })
+
+  it('returns 403 when workflow access is denied', async () => {
+    mockMarkExecutionCancelled.mockResolvedValue({ durablyRecorded: true, reason: 'recorded' })
+    mockAuthorizeWorkflowByWorkspacePermission.mockResolvedValue({
+      allowed: false,
+      message: 'Access denied',
+      status: 403,
+    })
+
+    const response = await POST(makeRequest(), makeParams())
+
+    expect(response.status).toBe(403)
+  })
 })