Merge pull request #124 from CSSLab/dev

Add ability to analyze entire game + fix position evaluation graph

Author: kevinjosethomas

__tests__/components/Analysis/AnalyzeEntireGame.test.tsx

@@ -0,0 +1,112 @@
+import React from 'react'
+import { render, screen } from '@testing-library/react'
+import { AnalysisConfigModal } from 'src/components/Analysis/AnalysisConfigModal'
+import { AnalysisProgressOverlay } from 'src/components/Analysis/AnalysisProgressOverlay'
+import '@testing-library/jest-dom'
+
+// Mock framer-motion to avoid animation issues in tests
+jest.mock('framer-motion', () => ({
+  motion: {
+    div: ({ children, ...props }: any) => <div {...props}>{children}</div>,
+  },
+  AnimatePresence: ({ children }: any) => <>{children}</>,
+}))
+
+describe('Analyze Entire Game Components', () => {
+  describe('AnalysisConfigModal', () => {
+    const defaultProps = {
+      isOpen: true,
+      onClose: jest.fn(),
+      onConfirm: jest.fn(),
+      initialDepth: 15,
+    }
+
+    it('renders the modal when open', () => {
+      render(<AnalysisConfigModal {...defaultProps} />)
+
+      expect(screen.getByText('Analyze Entire Game')).toBeInTheDocument()
+      expect(
+        screen.getByText(
+          'Choose the Stockfish analysis depth for all positions in the game:',
+        ),
+      ).toBeInTheDocument()
+    })
+
+    it('renders depth options', () => {
+      render(<AnalysisConfigModal {...defaultProps} />)
+
+      expect(screen.getByText('Fast (d12)')).toBeInTheDocument()
+      expect(screen.getByText('Balanced (d15)')).toBeInTheDocument()
+      expect(screen.getByText('Deep (d18)')).toBeInTheDocument()
+    })
+
+    it('renders start analysis button', () => {
+      render(<AnalysisConfigModal {...defaultProps} />)
+
+      expect(screen.getByText('Start Analysis')).toBeInTheDocument()
+      expect(screen.getByText('Cancel')).toBeInTheDocument()
+    })
+
+    it('does not render when closed', () => {
+      render(<AnalysisConfigModal {...defaultProps} isOpen={false} />)
+
+      expect(screen.queryByText('Analyze Entire Game')).not.toBeInTheDocument()
+    })
+  })
+
+  describe('AnalysisProgressOverlay', () => {
+    const mockProgress = {
+      currentMoveIndex: 5,
+      totalMoves: 20,
+      currentMove: 'e4',
+      isAnalyzing: true,
+      isComplete: false,
+      isCancelled: false,
+    }
+
+    const defaultProps = {
+      progress: mockProgress,
+      onCancel: jest.fn(),
+    }
+
+    it('renders progress overlay when analyzing', () => {
+      render(<AnalysisProgressOverlay {...defaultProps} />)
+
+      expect(screen.getByText('Analyzing Game')).toBeInTheDocument()
+      expect(
+        screen.getByText('Deep analysis in progress...'),
+      ).toBeInTheDocument()
+      expect(screen.getByText('Position 5 of 20')).toBeInTheDocument()
+      expect(screen.getByText('25%')).toBeInTheDocument()
+    })
+
+    it('renders current move being analyzed', () => {
+      render(<AnalysisProgressOverlay {...defaultProps} />)
+
+      expect(screen.getByText('Currently analyzing:')).toBeInTheDocument()
+      expect(screen.getByText('e4')).toBeInTheDocument()
+    })
+
+    it('renders cancel button', () => {
+      render(<AnalysisProgressOverlay {...defaultProps} />)
+
+      expect(screen.getByText('Cancel Analysis')).toBeInTheDocument()
+    })
+
+    it('does not render when not analyzing', () => {
+      const notAnalyzingProgress = {
+        ...mockProgress,
+        isAnalyzing: false,
+      }
+
+      render(
+        <AnalysisProgressOverlay
+          {...defaultProps}
+          progress={notAnalyzingProgress}
+        />,
+      )
+
+      expect(screen.queryByText('Analyzing Game')).not.toBeInTheDocument()
+    })
+  })
+})

__tests__/hooks/useOpeningDrillController-evaluation.test.ts

@@ -0,0 +1,157 @@
+import { GameTree, GameNode } from 'src/types'
+import { Chess } from 'chess.ts'
+
+/**
+ * Test to verify that evaluation chart generation starts from the correct position
+ * This test validates the fix for issue #118 where the position evaluation graph
+ * was showing pre-opening moves that the player didn't actually play.
+ */
+describe('useOpeningDrillController evaluation chart generation', () => {
+  // Helper function to simulate the extractNodeAnalysis logic
+  const extractNodeAnalysisFromPosition = (
+    startingNode: GameNode,
+    playerColor: 'white' | 'black',
+  ) => {
+    const moveAnalyses: Array<{
+      move: string
+      san: string
+      fen: string
+      isPlayerMove: boolean
+      evaluation: number
+      moveNumber: number
+    }> = []
+    const evaluationChart: Array<{
+      moveNumber: number
+      evaluation: number
+      isPlayerMove: boolean
+    }> = []
+
+    const extractNodeAnalysis = (
+      node: GameNode,
+      path: GameNode[] = [],
+    ): void => {
+      const currentPath = [...path, node]
+
+      if (node.move && node.san) {
+        const moveIndex = currentPath.length - 2
+        const isPlayerMove =
+          playerColor === 'white' ? moveIndex % 2 === 0 : moveIndex % 2 === 1
+
+        // Mock evaluation data
+        const evaluation = Math.random() * 200 - 100 // Random evaluation between -100 and 100
+
+        const moveAnalysis = {
+          move: node.move,
+          san: node.san,
+          fen: node.fen,
+          isPlayerMove,
+          evaluation,
+          moveNumber: Math.ceil((moveIndex + 1) / 2),
+        }
+
+        moveAnalyses.push(moveAnalysis)
+
+        const evaluationPoint = {
+          moveNumber: moveAnalysis.moveNumber,
+          evaluation,
+          isPlayerMove,
+        }
+
+        evaluationChart.push(evaluationPoint)
+      }
+
+      if (node.children.length > 0) {
+        extractNodeAnalysis(node.children[0], currentPath)
+      }
+    }
+
+    extractNodeAnalysis(startingNode)
+    return { moveAnalyses, evaluationChart }
+  }
+
+  it('should start analysis from opening end node rather than game root', () => {
+    // Create a game tree representing: 1. e4 e5 2. Nf3 Nc6 (opening) 3. Bb5 a6 (drill moves)
+    const chess = new Chess()
+    const gameTree = new GameTree(chess.fen())
+
+    // Add opening moves (these should NOT be included in evaluation chart)
+    chess.move('e4')
+    const e4Node = gameTree.addMainMove(
+      gameTree.getRoot(),
+      chess.fen(),
+      'e2e4',
+      'e4',
+    )!
+
+    chess.move('e5')
+    const e5Node = gameTree.addMainMove(e4Node, chess.fen(), 'e7e5', 'e5')!
+
+    chess.move('Nf3')
+    const nf3Node = gameTree.addMainMove(e5Node, chess.fen(), 'g1f3', 'Nf3')!
+
+    chess.move('Nc6')
+    const nc6Node = gameTree.addMainMove(nf3Node, chess.fen(), 'b8c6', 'Nc6')! // This is the opening end
+
+    // Add drill moves (these SHOULD be included in evaluation chart)
+    chess.move('Bb5')
+    const bb5Node = gameTree.addMainMove(nc6Node, chess.fen(), 'f1b5', 'Bb5')!
+
+    chess.move('a6')
+    const a6Node = gameTree.addMainMove(bb5Node, chess.fen(), 'a7a6', 'a6')!
+
+    // Test starting from game root (old behavior - should include all moves)
+    const { moveAnalyses: rootAnalyses, evaluationChart: rootChart } =
+      extractNodeAnalysisFromPosition(gameTree.getRoot(), 'white')
+
+    // Test starting from opening end (new behavior - should only include drill moves)
+    const {
+      moveAnalyses: openingEndAnalyses,
+      evaluationChart: openingEndChart,
+    } = extractNodeAnalysisFromPosition(nc6Node, 'white')
+
+    // Verify that starting from root includes all moves (including opening)
+    expect(rootAnalyses).toHaveLength(6) // e4, e5, Nf3, Nc6, Bb5, a6
+    expect(rootChart).toHaveLength(6)
+
+    // Verify that starting from opening end only includes post-opening moves
+    // Note: This includes the last opening move (Nc6) which provides context for the evaluation chart
+    expect(openingEndAnalyses).toHaveLength(3) // Nc6 (last opening move), Bb5, a6
+    expect(openingEndChart).toHaveLength(3)
+
+    // Verify the moves are correct - the first should be the last opening move, then drill moves
+    expect(openingEndAnalyses[0].san).toBe('Nc6') // Last opening move
+    expect(openingEndAnalyses[1].san).toBe('Bb5') // First drill move
+    expect(openingEndAnalyses[1].isPlayerMove).toBe(true) // White's move
+    expect(openingEndAnalyses[2].san).toBe('a6') // Second drill move
+    expect(openingEndAnalyses[2].isPlayerMove).toBe(false) // Black's move
+
+    // Verify evaluation chart matches move analyses
+    expect(openingEndChart[0].moveNumber).toBe(openingEndAnalyses[0].moveNumber)
+    expect(openingEndChart[1].moveNumber).toBe(openingEndAnalyses[1].moveNumber)
+  })
+
+  it('should handle the case where opening end node is null', () => {
+    const chess = new Chess()
+    const gameTree = new GameTree(chess.fen())
+
+    // Add some moves
+    chess.move('e4')
+    const e4Node = gameTree.addMainMove(
+      gameTree.getRoot(),
+      chess.fen(),
+      'e2e4',
+      'e4',
+    )!
+
+    // Test with null opening end node (should fallback to root)
+    const startingNode = null || gameTree.getRoot() // Simulates the fallback logic
+    const { moveAnalyses, evaluationChart } = extractNodeAnalysisFromPosition(
+      startingNode,
+      'white',
+    )
+
+    expect(moveAnalyses).toHaveLength(1)
+    expect(evaluationChart).toHaveLength(1)
+    expect(moveAnalyses[0].san).toBe('e4')
+  })
+})