Genarrative/apps/admin-web/src/pages/AdminGameManagementPage.test.tsx

/* @vitest-environment jsdom */

import {
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
  within,
} from '@testing-library/react';
import { afterEach, beforeEach, expect, test, vi } from 'vitest';

import {
  listAdminGameDistributionGames,
  restoreAdminGameDistributionGame,
  suspendAdminGameDistributionGame,
} from '../api/adminApiClient';
import type {
  AdminGameDistributionGameEntry,
  AdminGameDistributionGameVersionEntry,
} from '../api/adminApiTypes';
import { AdminGameManagementPage } from './AdminGameManagementPage';

vi.mock('../api/adminApiClient', () => ({
  isAdminApiError: vi.fn(
    (error: unknown) =>
      typeof error === 'object' &&
      error !== null &&
      'status' in error &&
      typeof error.status === 'number',
  ),
  formatAdminApiError: vi.fn((error: unknown) =>
    error instanceof Error ? error.message : '请求失败',
  ),
  listAdminGameDistributionGames: vi.fn(),
  restoreAdminGameDistributionGame: vi.fn(),
  suspendAdminGameDistributionGame: vi.fn(),
}));

const version: AdminGameDistributionGameVersionEntry = {
  versionId: 'version-3',
  gameId: 'game_1',
  versionNumber: 3,
  status: 'published',
  reviewReason: '测试原因',
  packageBytes: 2048,
  packageSha256:
    'abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789',
  createdAt: '2026-09-20T08:00:00Z',
  updatedAt: '2026-09-20T08:00:00Z',
  reviewedAt: '2026-09-20T09:00:00Z',
  publishedAt: '2026-09-20T10:00:00Z',
  entryUrl: 'https://game.example.com/game_1',
};

const publishedGame: AdminGameDistributionGameEntry = {
  gameId: 'game_1',
  title: '测试游戏',
  author: {
    id: 'user_1',
    name: '作者甲',
    avatarUrl: 'https://example.com/avatar.png',
  },
  status: 'published',
  versionCount: 21,
  playCount: 345,
  activeVersionId: 'version-3',
  publicationRevision: 4,
  createdAt: '2026-09-18T08:00:00Z',
  updatedAt: '2026-09-20T10:00:00Z',
  versions: [version],
};

const suspendedGame: AdminGameDistributionGameEntry = {
  gameId: 'game_2',
  title: '下架游戏',
  author: {
    id: 'user_2',
    name: '作者乙',
    avatarUrl: null,
  },
  status: 'suspended',
  versionCount: 2,
  playCount: 8,
  activeVersionId: null,
  publicationRevision: 7,
  createdAt: '2026-09-19T08:00:00Z',
  updatedAt: '2026-09-21T08:00:00Z',
  versions: [],
};

beforeEach(() => {
  vi.mocked(listAdminGameDistributionGames)
    .mockReset()
    .mockResolvedValue({ games: [publishedGame] });
  vi.mocked(restoreAdminGameDistributionGame)
    .mockReset()
    .mockResolvedValue({
      game: {
        id: suspendedGame.gameId,
        title: suspendedGame.title,
        status: 'published',
        publicationRevision: 8,
      },
      replayed: false,
    });
  vi.mocked(suspendAdminGameDistributionGame)
    .mockReset()
    .mockResolvedValue({
      game: {
        id: publishedGame.gameId,
        title: publishedGame.title,
        status: 'suspended',
        publicationRevision: 5,
      },
      replayed: false,
    });
});

afterEach(() => {
  cleanup();
  vi.restoreAllMocks();
});

test('列表展示作者头像、状态、版本数和游玩数', async () => {
  vi.mocked(listAdminGameDistributionGames).mockResolvedValue({
    games: [publishedGame, suspendedGame],
  });

  render(
    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
  );

  const publishedRow = (await screen.findByText('测试游戏')).closest('tr')!;
  expect(within(publishedRow).getByText('作者甲')).toBeTruthy();
  const avatar = within(publishedRow).getByRole('img', {
    name: '作者甲 头像',
  });
  expect(avatar.getAttribute('src')).toBe('https://example.com/avatar.png');
  expect(within(publishedRow).getByText('已公开')).toBeTruthy();
  expect(within(publishedRow).getByText('21')).toBeTruthy();
  expect(within(publishedRow).getByText('345')).toBeTruthy();

  const suspendedRow = (await screen.findByText('下架游戏')).closest('tr')!;
  expect(within(suspendedRow).getByText('作者乙')).toBeTruthy();
  expect(suspendedRow.querySelector('.admin-user-avatar')?.textContent).toBe(
    '作',
  );
  expect(within(suspendedRow).getByText('已下架')).toBeTruthy();
});

test('恢复按钮只在下架态出现，成功后携带幂等键并刷新列表', async () => {
  vi.mocked(listAdminGameDistributionGames)
    .mockResolvedValueOnce({ games: [suspendedGame] })
    .mockResolvedValueOnce({
      games: [{ ...suspendedGame, status: 'published' }],
    });

  render(
    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
  );

  await screen.findByText('下架游戏');
  expect(screen.queryByRole('button', { name: '下架' })).toBeNull();
  fireEvent.click(screen.getByRole('button', { name: '恢复' }));

  expect(restoreAdminGameDistributionGame).not.toHaveBeenCalled();
  await screen.findByRole('dialog');
  fireEvent.click(screen.getByRole('button', { name: '确认' }));

  await waitFor(() =>
    expect(restoreAdminGameDistributionGame).toHaveBeenCalledTimes(1),
  );
  const [token, gameId, idempotencyKey, payload] =
    vi.mocked(restoreAdminGameDistributionGame).mock.calls[0] ?? [];
  expect(token).toBe('admin-token');
  expect(gameId).toBe('game_2');
  expect(String(idempotencyKey)).toContain('game_2');
  expect(payload).toEqual({ expectedPublicationRevision: 7 });
  await waitFor(() =>
    expect(listAdminGameDistributionGames).toHaveBeenCalledTimes(2),
  );
  expect(await screen.findByText('游戏《下架游戏》已恢复')).toBeTruthy();
});

test('下架需要原因和二次确认，提交原因与当前公开修订号', async () => {
  render(
    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
  );

  await screen.findByText('测试游戏');
  fireEvent.change(screen.getByLabelText('下架原因'), {
    target: { value: '违规内容' },
  });
  fireEvent.click(screen.getByRole('button', { name: '下架' }));

  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
  await screen.findByRole('dialog');
  fireEvent.click(screen.getByRole('button', { name: '确认' }));

  await waitFor(() =>
    expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
  );
  const [token, gameId, idempotencyKey, payload] =
    vi.mocked(suspendAdminGameDistributionGame).mock.calls[0] ?? [];
  expect(token).toBe('admin-token');
  expect(gameId).toBe('game_1');
  expect(String(idempotencyKey)).toContain('game_1');
  expect(payload).toEqual({
    expectedPublicationRevision: 4,
    reason: '违规内容',
  });
  expect(await screen.findByText('游戏《测试游戏》已下架')).toBeTruthy();
});

test('版本历史弹层展示版本条目与统计信息', async () => {
  render(
    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
  );

  await screen.findByText('测试游戏');
  fireEvent.click(screen.getByRole('button', { name: '版本历史' }));
  const dialog = await screen.findByRole('dialog');

  expect(within(dialog).getByText('共 21 个版本，展示最近 20 个')).toBeTruthy();
  expect(within(dialog).getByText('v3')).toBeTruthy();
  expect(within(dialog).getByText('published')).toBeTruthy();
  expect(within(dialog).getByText('2.0 KiB')).toBeTruthy();
  expect(within(dialog).getByText('abcdef012345')).toBeTruthy();
  expect(within(dialog).getByText('测试原因')).toBeTruthy();
  expect(
    within(dialog).getByText('https://game.example.com/game_1'),
  ).toBeTruthy();
});

test('接口失败显示错误文案', async () => {
  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
    new Error('游戏列表读取失败'),
  );

  render(
    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
  );

  expect(await screen.findByText('游戏列表读取失败')).toBeTruthy();
});

test('401 交给 onUnauthorized 处理', async () => {
  const onUnauthorized = vi.fn();
  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
    Object.assign(new Error('未授权'), { status: 401 }),
  );

  render(
    <AdminGameManagementPage
      token="admin-token"
      onUnauthorized={onUnauthorized}
    />,
  );

  await waitFor(() =>
    expect(onUnauthorized).toHaveBeenCalledWith('登录状态已失效'),
  );
  expect(screen.queryByRole('alert')).toBeNull();
});