fix: prevent moving unassigned bugs out of backlog

Add validation to prevent moving bugs assigned to nobody@mozilla.org
out of the backlog column. Bugzilla requires a real assignee for
ASSIGNED, IN_PROGRESS, and RESOLVED statuses.

- Add validateMove helper to check if move is valid
- Add onInvalidMove callback to Board for error handling
- Show toast error when invalid move is attempted
- Allow move if assignee is staged to change to a real person

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: msujaws

src/App.tsx

@@ -118,6 +118,14 @@ function App() {
     [bugs, stageAssigneeChange],
   )
 
+  // Handle invalid move attempt (e.g., unassigned bug out of backlog)
+  const handleInvalidMove = useCallback(
+    (_bugId: number, reason: string) => {
+      addToast('error', reason)
+    },
+    [addToast],
+  )
+
   // Handle clear staged changes
   const handleClearChanges = useCallback(() => {
     clearAllChanges()
@@ -275,6 +283,7 @@ function App() {
           stagedChanges={changes}
           onBugMove={handleBugMove}
           onAssigneeChange={handleAssigneeChange}
+          onInvalidMove={handleInvalidMove}
           isLoading={isLoadingBugs}
           onApplyChanges={handleApplyChanges}
           onClearChanges={handleClearChanges}

src/components/Board/Board.test.tsx

@@ -772,5 +772,108 @@ describe('Board', () => {
         expect(screen.getByText(/drop here/i)).toBeInTheDocument()
       })
     })
+
+    describe('unassigned bug move validation', () => {
+      const nobodyBug: BugzillaBug = {
+        id: 99,
+        summary: 'Unassigned bug',
+        status: 'NEW',
+        assigned_to: 'nobody@mozilla.org',
+        priority: 'P2',
+        severity: 'normal',
+        component: 'Core',
+        whiteboard: '[kanban]',
+        last_change_time: '2024-01-15T10:00:00Z',
+        creation_time: '2024-01-01T00:00:00Z',
+      }
+
+      it('should call onInvalidMove when trying to move unassigned bug out of backlog', () => {
+        const onBugMove = vi.fn()
+        const onInvalidMove = vi.fn()
+        render(
+          <Board
+            {...defaultProps}
+            bugs={[nobodyBug]}
+            onBugMove={onBugMove}
+            onInvalidMove={onInvalidMove}
+          />,
+        )
+
+        // Select the bug
+        fireEvent.keyDown(document, { key: 'ArrowDown' })
+        // Grab it
+        fireEvent.keyDown(document, { key: 'Shift' })
+        // Move right to todo
+        fireEvent.keyDown(document, { key: 'ArrowRight' })
+        // Release to drop
+        fireEvent.keyUp(document, { key: 'Shift' })
+
+        expect(onBugMove).not.toHaveBeenCalled()
+        expect(onInvalidMove).toHaveBeenCalledWith(99, expect.stringContaining('assign'))
+      })
+
+      it('should allow moving unassigned bug if assignee is staged to change', () => {
+        const onBugMove = vi.fn()
+        const onInvalidMove = vi.fn()
+        const stagedChanges = new Map<number, StagedChange>([
+          [99, { assignee: { from: 'nobody@mozilla.org', to: 'dev@mozilla.com' } }],
+        ])
+        render(
+          <Board
+            {...defaultProps}
+            bugs={[nobodyBug]}
+            stagedChanges={stagedChanges}
+            onBugMove={onBugMove}
+            onInvalidMove={onInvalidMove}
+          />,
+        )
+
+        // Select the bug
+        fireEvent.keyDown(document, { key: 'ArrowDown' })
+        // Grab it
+        fireEvent.keyDown(document, { key: 'Shift' })
+        // Move right to todo
+        fireEvent.keyDown(document, { key: 'ArrowRight' })
+        // Release to drop
+        fireEvent.keyUp(document, { key: 'Shift' })
+
+        expect(onBugMove).toHaveBeenCalledWith(99, 'backlog', 'todo')
+        expect(onInvalidMove).not.toHaveBeenCalled()
+      })
+
+      it('should still block move if staged assignee is also nobody', () => {
+        const onBugMove = vi.fn()
+        const onInvalidMove = vi.fn()
+        const stagedChanges = new Map<number, StagedChange>([
+          [99, { assignee: { from: 'dev@mozilla.com', to: 'nobody@mozilla.org' } }],
+        ])
+        // Bug originally had a real assignee, but staged to nobody
+        const bugWithStagedNobody: BugzillaBug = {
+          ...nobodyBug,
+          assigned_to: 'dev@mozilla.com',
+        }
+        render(
+          <Board
+            {...defaultProps}
+            bugs={[bugWithStagedNobody]}
+            stagedChanges={stagedChanges}
+            onBugMove={onBugMove}
+            onInvalidMove={onInvalidMove}
+          />,
+        )
+
+        // Select the bug
+        fireEvent.keyDown(document, { key: 'ArrowDown' })
+        // Grab it
+        fireEvent.keyDown(document, { key: 'Shift' })
+        // Move right to todo
+        fireEvent.keyDown(document, { key: 'ArrowRight' })
+        // Release to drop
+        fireEvent.keyUp(document, { key: 'Shift' })
+
+        expect(onBugMove).not.toHaveBeenCalled()
+        expect(onInvalidMove).toHaveBeenCalled()
+      })
+    })
   })
 })

src/components/Board/Board.tsx

@@ -16,11 +16,14 @@ import type { BugzillaBug } from '@/lib/bugzilla/types'
 import type { StagedChange } from '@/store/slices/staged-slice'
 import { useBoardAssignees } from '@/hooks/use-board-assignees'
 
+const NOBODY_EMAIL = 'nobody@mozilla.org'
+
 interface BoardProps {
   bugs: BugzillaBug[]
   stagedChanges: Map<number, StagedChange>
   onBugMove: (bugId: number, fromColumn: KanbanColumn, toColumn: KanbanColumn) => void
   onAssigneeChange?: (bugId: number, newAssignee: string) => void
+  onInvalidMove?: (bugId: number, reason: string) => void
   isLoading?: boolean
   onApplyChanges?: () => void
   onClearChanges?: () => void
@@ -39,6 +42,7 @@ export function Board({
   stagedChanges,
   onBugMove,
   onAssigneeChange,
+  onInvalidMove,
   isLoading = false,
   onApplyChanges,
   onClearChanges,
@@ -118,6 +122,28 @@ export function Board({
   // Get all assignees from bugs on the board
   const allAssignees = useBoardAssignees(bugs)
 
+  // Check if a bug can be moved out of backlog
+  // Returns error message if invalid, undefined if valid
+  const validateMove = useCallback(
+    (bugId: number, fromColumn: KanbanColumn, toColumn: KanbanColumn): string | undefined => {
+      // Only validate moves OUT of backlog
+      if (fromColumn === 'backlog' && toColumn !== 'backlog') {
+        const bug = bugs.find((b) => b.id === bugId)
+        if (!bug) return undefined
+
+        // Check the effective assignee (staged or original)
+        const stagedChange = stagedChanges.get(bugId)
+        const effectiveAssignee = stagedChange?.assignee?.to ?? bug.assigned_to
+
+        if (effectiveAssignee === NOBODY_EMAIL) {
+          return 'Cannot move unassigned bug out of backlog. Please assign someone first.'
+        }
+      }
+      return undefined
+    },
+    [bugs, stagedChanges],
+  )
+
   // Find first non-empty column
   const findFirstNonEmptyColumn = useCallback((): number => {
     for (const [i, column] of columns.entries()) {
@@ -326,15 +352,29 @@ export function Board({
           const fromColumn = columns[grabStartColumn]
           const toColumn = columns[targetColumnIndex]
           if (fromColumn && toColumn) {
-            onBugMove(grabbedBugId, fromColumn, toColumn)
+            // Validate the move
+            const error = validateMove(grabbedBugId, fromColumn, toColumn)
+            if (error) {
+              onInvalidMove?.(grabbedBugId, error)
+            } else {
+              onBugMove(grabbedBugId, fromColumn, toColumn)
+            }
           }
         }
         setGrabStartColumn(null)
         setGrabbedBugId(null)
         setTargetColumnIndex(null)
       }
     },
-    [isGrabbing, grabStartColumn, grabbedBugId, targetColumnIndex, onBugMove],
+    [
+      isGrabbing,
+      grabStartColumn,
+      grabbedBugId,
+      targetColumnIndex,
+      onBugMove,
+      validateMove,
+      onInvalidMove,
+    ],
   )
 
   // Set up keyboard event listeners
@@ -378,7 +418,13 @@ export function Board({
 
     // Only trigger move if dropping on a different column
     if (currentColumn !== targetColumn) {
-      onBugMove(bugId, currentColumn, targetColumn)
+      // Validate the move
+      const error = validateMove(bugId, currentColumn, targetColumn)
+      if (error) {
+        onInvalidMove?.(bugId, error)
+      } else {
+        onBugMove(bugId, currentColumn, targetColumn)
+      }
     }
   }