mantimon-tcg/frontend/src/composables/useGameSocket.spec.ts

import { describe, it, expect, beforeEach, vi } from 'vitest'
import { setActivePinia, createPinia } from 'pinia'

import { useGameSocket } from './useGameSocket'
import { useAuthStore } from '@/stores/auth'
import { useGameStore } from '@/stores/game'
import { ConnectionStatus } from '@/types'
import type { VisibleGameState } from '@/types/game'

// Mock socket.io-client - simplified mocking
vi.mock('socket.io-client', () => ({
  io: vi.fn(() => ({
    connected: false,
    on: vi.fn(),
    once: vi.fn(),
    off: vi.fn(),
    emit: vi.fn(),
    disconnect: vi.fn(),
    io: { on: vi.fn() },
  })),
}))

describe('useGameSocket', () => {
  let authStore: ReturnType<typeof useAuthStore>
  let gameStore: ReturnType<typeof useGameStore>

  beforeEach(() => {
    setActivePinia(createPinia())
    authStore = useAuthStore()
    gameStore = useGameStore()

    // Setup valid auth token
    authStore.setTokens({
      accessToken: 'mock-token',
      refreshToken: 'mock-refresh',
      expiresAt: Date.now() + 3600000,
    })

    vi.clearAllMocks()
  })

  // ---------------------------------------------------------------------------
  // Authentication
  // ---------------------------------------------------------------------------

  it('requires authentication to connect', async () => {
    /**
     * Test that connection fails when user is not authenticated.
     *
     * WebSocket connections require valid authentication. If the user
     * is not logged in or the token is invalid, the connection should
     * fail immediately with a clear error message.
     */
    authStore.accessToken = null

    const { connect } = useGameSocket()

    await expect(connect('game-123')).rejects.toThrow('Not authenticated')
  })

  // ---------------------------------------------------------------------------
  // Connection State
  // ---------------------------------------------------------------------------

  it('initializes with disconnected state', () => {
    /**
     * Test that the composable starts in a disconnected state.
     *
     * Before calling connect(), the composable should indicate that
     * no connection is active. This ensures a clean initial state.
     */
    const { isConnected, currentGameId } = useGameSocket()

    expect(isConnected.value).toBe(false)
    expect(currentGameId.value).toBeNull()
  })

  it('rejects duplicate connection attempts', async () => {
    /**
     * Test that attempting to connect while already connecting fails.
     *
     * If connect() is called while a connection is already in progress,
     * it should reject immediately to prevent race conditions.
     */
    const { connect } = useGameSocket()

    // Start first connection
    const promise1 = connect('game-123')

    // Immediately try to connect again
    await expect(connect('game-123')).rejects.toThrow('Connection already in progress')

    // Clean up - Note: First promise will time out or fail, that's okay for this test
    promise1.catch(() => {})  // Suppress unhandled rejection
  })

  // ---------------------------------------------------------------------------
  // Action Queueing
  // ---------------------------------------------------------------------------

  it('queues actions when not connected', async () => {
    /**
     * Test that actions are queued when the connection is lost.
     *
     * If the user tries to perform an action while disconnected,
     * we should queue it for retry when the connection is restored.
     * This prevents losing actions during brief network interruptions.
     */
    const { sendAction } = useGameSocket()

    const mockAction = {
      type: 'play_card' as const,
      instance_id: 'card-1',
    }

    await expect(sendAction(mockAction)).rejects.toThrow('Not connected')

    // Check that action was queued in the game store
    expect(gameStore.pendingActions).toHaveLength(1)
    expect(gameStore.pendingActions[0]).toEqual(mockAction)
  })

  it('requires game context for actions', async () => {
    /**
     * Test that actions fail when not in a game.
     *
     * sendAction() should only work when connected to a specific game.
     * This prevents accidental action sends before joining a game.
     */
    const { sendAction } = useGameSocket()

    const mockAction = {
      type: 'end_turn' as const,
    }

    await expect(sendAction(mockAction)).rejects.toThrow()
  })

  // ---------------------------------------------------------------------------
  // Cleanup
  // ---------------------------------------------------------------------------

  it('clears state on disconnect', () => {
    /**
     * Test that disconnect() clears game state.
     *
     * When leaving a game, the composable should reset to initial state.
     * This includes clearing the current game ID and game state.
     */
    const { disconnect, currentGameId } = useGameSocket()

    // Set up some state
    gameStore.currentGameId = 'game-123'
    gameStore.gameState = {} as VisibleGameState

    disconnect()

    expect(currentGameId.value).toBeNull()
    expect(gameStore.gameState).toBeNull()
  })

  it('sets disconnected status on disconnect', () => {
    /**
     * Test that disconnect() updates connection status.
     *
     * The connection status should be set to DISCONNECTED so the UI
     * can react appropriately (hide game UI, show lobby, etc.).
     */
    const { disconnect } = useGameSocket()

    // Simulate being connected
    gameStore.setConnectionStatus(ConnectionStatus.CONNECTED)

    disconnect()

    expect(gameStore.connectionStatus).toBe(ConnectionStatus.DISCONNECTED)
  })

  // ---------------------------------------------------------------------------
  // Integration with Stores
  // ---------------------------------------------------------------------------

  it('integrates with game store for state', () => {
    /**
     * Test that the composable updates the game store.
     *
     * All game state should flow through the game store as the single
     * source of truth. This test verifies the integration is set up.
     */
    const { disconnect } = useGameSocket()

    // Verify we can interact with game store through the composable
    disconnect()

    // State should be cleared via the store
    expect(gameStore.currentGameId).toBeNull()
  })

  // ---------------------------------------------------------------------------
  // Return API
  // ---------------------------------------------------------------------------

  it('exposes the correct API', () => {
    /**
     * Test that the composable returns the expected interface.
     *
     * Components using this composable depend on a specific API.
     * This test ensures the public interface is complete and correct.
     */
    const api = useGameSocket()

    expect(api).toHaveProperty('isConnected')
    expect(api).toHaveProperty('isConnecting')
    expect(api).toHaveProperty('currentGameId')
    expect(api).toHaveProperty('lastHeartbeatAck')
    expect(api).toHaveProperty('connect')
    expect(api).toHaveProperty('disconnect')
    expect(api).toHaveProperty('sendAction')
    expect(api).toHaveProperty('sendResign')

    expect(typeof api.connect).toBe('function')
    expect(typeof api.disconnect).toBe('function')
    expect(typeof api.sendAction).toBe('function')
    expect(typeof api.sendResign).toBe('function')
  })
})