fix tests

Author: icecrasher321

apps/sim/lib/workflows/persistence/duplicate.test.ts

@@ -382,4 +382,97 @@ describe('duplicateWorkflow ordering', () => {
     expect(remappedVarId).toBe(newVarIds[0])
     expect(copiedSubBlocks.variables.value[0].variableName).toBe('customerName')
   })
+
+  it('preserves stale variable references instead of failing the duplicate', async () => {
+    let insertedBlocks: Array<Record<string, unknown>> | null = null
+    const tx = createMockTx(
+      [
+        [
+          {
+            id: 'source-workflow-id',
+            workspaceId: 'workspace-123',
+            folderId: null,
+            description: 'source',
+            color: '#000000',
+            variables: {
+              'live-var-id': {
+                id: 'live-var-id',
+                workflowId: 'source-workflow-id',
+                name: 'customerName',
+                type: 'string',
+                value: 'Ada',
+              },
+            },
+          },
+        ],
+        [],
+        [],
+        [
+          {
+            id: 'source-block-id',
+            workflowId: 'source-workflow-id',
+            type: 'agent',
+            name: 'Agent',
+            parentId: null,
+            extent: null,
+            data: {},
+            subBlocks: {
+              variables: {
+                id: 'variables',
+                type: 'variables-input',
+                value: [
+                  {
+                    id: 'assignment-1',
+                    variableId: 'deleted-var-id',
+                    variableName: 'customerName',
+                    type: 'string',
+                    value: 'Grace',
+                    isExisting: true,
+                  },
+                ],
+              },
+            },
+            position: { x: 0, y: 0 },
+            enabled: true,
+            horizontalHandles: true,
+            isWide: false,
+            height: 0,
+            advancedMode: false,
+            triggerMode: false,
+            locked: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+        ],
+        [],
+        [],
+      ],
+      undefined,
+      (values) => {
+        if (Array.isArray(values)) {
+          insertedBlocks = values as Array<Record<string, unknown>>
+        }
+      }
+    )
+
+    mockDb.transaction.mockImplementation(async (callback: (txArg: unknown) => Promise<unknown>) =>
+      callback(tx)
+    )
+
+    await expect(
+      duplicateWorkflow({
+        sourceWorkflowId: 'source-workflow-id',
+        userId: 'user-123',
+        name: 'Duplicated',
+        workspaceId: 'workspace-123',
+        folderId: null,
+        requestId: 'req-stale',
+      })
+    ).resolves.toBeDefined()
+
+    expect(insertedBlocks).toHaveLength(1)
+    const copiedSubBlocks = insertedBlocks?.[0].subBlocks as Record<string, any>
+    expect(copiedSubBlocks.variables.value[0].variableId).toBe('deleted-var-id')
+    expect(copiedSubBlocks.variables.value[0].variableName).toBe('customerName')
+  })
 })

apps/sim/lib/workflows/persistence/duplicate.ts

@@ -134,10 +134,13 @@ function remapVariableAssignment(value: unknown, varIdMap: Map<string, string>):
 
   if (typeof assignment.variableId === 'string') {
     const newVarId = varIdMap.get(assignment.variableId)
-    if (!newVarId) {
-      throw new Error(`Variable reference ${assignment.variableId} could not be remapped`)
+    if (newVarId) {
+      next.variableId = newVarId
+    } else {
+      logger.warn('Skipping unknown variable reference during duplication', {
+        variableId: assignment.variableId,
+      })
     }
-    next.variableId = newVarId
   }
 
   return next

packages/testing/src/mocks/workflow-authz.mock.ts

@@ -1,8 +1,47 @@
 import { vi } from 'vitest'
 
+/**
+ * Real `WorkflowLockedError` subclass used by tests so `instanceof` checks in
+ * route handlers behave the same as in production. Mirrors the shape exported
+ * by `@sim/workflow-authz`.
+ */
+export class MockWorkflowLockedError extends Error {
+  readonly status = 423
+
+  constructor(message = 'Workflow is locked') {
+    super(message)
+    this.name = 'WorkflowLockedError'
+  }
+}
+
+/**
+ * Real `FolderLockedError` subclass used by tests so `instanceof` checks in
+ * route handlers behave the same as in production. Mirrors the shape exported
+ * by `@sim/workflow-authz`.
+ */
+export class MockFolderLockedError extends Error {
+  readonly status = 423
+
+  constructor(message = 'Folder is locked') {
+    super(message)
+    this.name = 'FolderLockedError'
+  }
+}
+
+const unlockedStatus = {
+  locked: false,
+  directLocked: false,
+  inheritedLocked: false,
+  lockedBy: null as 'workflow' | 'folder' | null,
+  lockedFolderId: null as string | null,
+}
+
 /**
  * Controllable mocks for the `@sim/workflow-authz` package.
  *
+ * Defaults assume permissive access (no lock, write allowed). Override with
+ * `mockResolvedValue` per test when exercising the lock/permission paths.
+ *
  * @example
  * ```ts
  * import { workflowAuthzMockFns } from '@sim/testing'
@@ -20,6 +59,10 @@ export const workflowAuthzMockFns = {
   mockGetActiveWorkflowContext: vi.fn(),
   mockGetActiveWorkflowRecord: vi.fn(),
   mockAssertActiveWorkflowContext: vi.fn(),
+  mockGetFolderLockStatus: vi.fn().mockResolvedValue(unlockedStatus),
+  mockGetWorkflowLockStatus: vi.fn().mockResolvedValue(unlockedStatus),
+  mockAssertWorkflowMutable: vi.fn().mockResolvedValue(undefined),
+  mockAssertFolderMutable: vi.fn().mockResolvedValue(undefined),
 }
 
 /**
@@ -36,4 +79,10 @@ export const workflowAuthzMock = {
   getActiveWorkflowContext: workflowAuthzMockFns.mockGetActiveWorkflowContext,
   getActiveWorkflowRecord: workflowAuthzMockFns.mockGetActiveWorkflowRecord,
   assertActiveWorkflowContext: workflowAuthzMockFns.mockAssertActiveWorkflowContext,
+  getFolderLockStatus: workflowAuthzMockFns.mockGetFolderLockStatus,
+  getWorkflowLockStatus: workflowAuthzMockFns.mockGetWorkflowLockStatus,
+  assertWorkflowMutable: workflowAuthzMockFns.mockAssertWorkflowMutable,
+  assertFolderMutable: workflowAuthzMockFns.mockAssertFolderMutable,
+  WorkflowLockedError: MockWorkflowLockedError,
+  FolderLockedError: MockFolderLockedError,
 }