#!/usr/bin/env vpython3
# Copyright 2026 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Unit tests for code_coverage_installer.py."""

import contextlib
import io
import pathlib
import unittest
from unittest.mock import patch

from pyfakefs import fake_filesystem_unittest

import code_coverage_installer


class CodeCoverageInstallerTest(fake_filesystem_unittest.TestCase):
  """Tests individual filesystem verification and setup helper functions."""

  def setUp(self) -> None:
    """Sets up virtual filesystem, stream redirection, and command mock."""
    self.setUpPyfakefs()
    self.src_root = pathlib.Path('/src')
    self.fs.create_dir('/src')

    self.enterContext(contextlib.redirect_stdout(io.StringIO()))
    self.enterContext(contextlib.redirect_stderr(io.StringIO()))

    self.run_command_patcher = patch('code_coverage_installer.run_command')
    self.mock_run_command = self.run_command_patcher.start()
    self.addCleanup(self.run_command_patcher.stop)

  def test_verify_chromium_checkout_success(self) -> None:
    """Verifies checkout succeeds when DEPS file exists."""
    self.fs.create_file('/src/DEPS')
    result = code_coverage_installer.verify_chromium_checkout(self.src_root)
    self.assertTrue(result)

  def test_verify_chromium_checkout_missing_deps(self) -> None:
    """Verifies checkout fails when DEPS file is missing."""
    result = code_coverage_installer.verify_chromium_checkout(self.src_root)
    self.assertFalse(result)

  def test_verify_llvm_tools_success(self) -> None:
    """Verifies LLVM tools check succeeds when both binaries exist."""
    self.fs.create_file(
      '/src/third_party/llvm-build/Release+Asserts/bin/llvm-cov'
    )
    self.fs.create_file(
      '/src/third_party/llvm-build/Release+Asserts/bin/llvm-profdata'
    )
    result = code_coverage_installer.verify_llvm_tools(self.src_root)
    self.assertTrue(result)

  def test_verify_llvm_tools_missing(self) -> None:
    """Verifies LLVM tools check fails when binaries are missing."""
    result = code_coverage_installer.verify_llvm_tools(self.src_root)
    self.assertFalse(result)

  def test_verify_recipes_success(self) -> None:
    """Verifies recipes check succeeds when recipe module folder exists."""
    self.fs.create_dir('/infra_dir/build/recipes/recipe_modules/code_coverage')
    infra_dir = pathlib.Path('/infra_dir')
    result = code_coverage_installer.verify_recipes(infra_dir)
    self.assertTrue(result)

  def test_verify_recipes_missing(self) -> None:
    """Verifies recipes check fails when recipe module folder is missing."""
    infra_dir = pathlib.Path('/infra_dir')
    result = code_coverage_installer.verify_recipes(infra_dir)
    self.assertFalse(result)

  def test_verify_service_success(self) -> None:
    """Verifies FindIt service check succeeds when service directory exists."""
    self.fs.create_dir('/infra_dir/infra/appengine/findit')
    infra_dir = pathlib.Path('/infra_dir')
    result = code_coverage_installer.verify_service(infra_dir)
    self.assertTrue(result)

  def test_verify_service_missing(self) -> None:
    """Verifies FindIt service check fails when service directory is missing."""
    infra_dir = pathlib.Path('/infra_dir')
    result = code_coverage_installer.verify_service(infra_dir)
    self.assertFalse(result)

  def test_setup_infra_gclient_exists_sync_success(self) -> None:
    """Verifies running gclient sync when .gclient already exists."""
    infra_dir = pathlib.Path('/infra_dir')
    self.fs.create_file('/infra_dir/.gclient')
    self.mock_run_command.return_value = 0
    result = code_coverage_installer.setup_infra(infra_dir)
    self.assertTrue(result)
    self.mock_run_command.assert_called_once_with(
      ['gclient', 'sync'], cwd=infra_dir
    )

  def test_setup_infra_gclient_exists_sync_failure(self) -> None:
    """Verifies setup fails when gclient sync returns non-zero code."""
    infra_dir = pathlib.Path('/infra_dir')
    self.fs.create_file('/infra_dir/.gclient')
    self.mock_run_command.return_value = 1
    result = code_coverage_installer.setup_infra(infra_dir)
    self.assertFalse(result)

  def test_setup_infra_no_gclient_fetch_success(self) -> None:
    """Verifies fetch infra_superproject runs when .gclient is missing."""
    infra_dir = pathlib.Path('/infra_dir')
    self.mock_run_command.return_value = 0
    result = code_coverage_installer.setup_infra(infra_dir)
    self.assertTrue(result)
    self.mock_run_command.assert_called_once_with(
      ['fetch', 'infra_superproject'], cwd=infra_dir
    )

  def test_setup_infra_no_gclient_fetch_failure(self) -> None:
    """Verifies setup fails when fetch infra_superproject returns non-zero."""
    infra_dir = pathlib.Path('/infra_dir')
    self.mock_run_command.return_value = 1
    result = code_coverage_installer.setup_infra(infra_dir)
    self.assertFalse(result)

  def test_fs_permission_error_handled(self) -> None:
    """Verifies filesystem permission errors are caught gracefully."""
    with patch(
      'pathlib.Path.exists', side_effect=PermissionError('Access Denied')
    ):
      result = code_coverage_installer.verify_chromium_checkout(self.src_root)
    self.assertFalse(result)

  def test_verify_gemini_md_creates_new(self) -> None:
    """Verifies creating GEMINI.md with template import when file missing."""
    result = code_coverage_installer.verify_gemini_md(self.src_root)
    self.assertTrue(result)
    content = (self.src_root / 'GEMINI.md').read_text(encoding='utf-8')
    self.assertIn('@agents/prompts/templates/code_coverage.md', content)

  def test_verify_gemini_md_appends_existing(self) -> None:
    """Verifies appending template import when GEMINI.md already exists."""
    gemini_path = self.src_root / 'GEMINI.md'
    gemini_path.write_text('# Existing prompt\n', encoding='utf-8')
    result = code_coverage_installer.verify_gemini_md(self.src_root)
    self.assertTrue(result)
    content = gemini_path.read_text(encoding='utf-8')
    self.assertIn('# Existing prompt', content)
    self.assertIn('@agents/prompts/templates/code_coverage.md', content)

  def test_verify_gemini_md_already_present(self) -> None:
    """Verifies no duplicate entry added when import is already present."""
    gemini_path = self.src_root / 'GEMINI.md'
    gemini_path.write_text(
      '@agents/prompts/templates/code_coverage.md\n', encoding='utf-8'
    )
    result = code_coverage_installer.verify_gemini_md(self.src_root)
    self.assertTrue(result)


class CodeCoverageInstallerMainTest(unittest.TestCase):
  """Tests full CLI main() workflow with mocked environment verification."""

  def setUp(self) -> None:
    """Initializes all verification patchers to isolate main() CLI execution."""
    self.enterContext(contextlib.redirect_stdout(io.StringIO()))
    self.enterContext(contextlib.redirect_stderr(io.StringIO()))

    self.patcher_argv = patch(
      'sys.argv', ['code_coverage_installer.py', '--infra-dir', '/infra_dir']
    )
    self.patcher_exit = patch('sys.exit', side_effect=SystemExit)
    self.patcher_gemini = patch(
      'code_coverage_installer.verify_gemini_md', return_value=True
    )
    self.patcher_checkout = patch(
      'code_coverage_installer.verify_chromium_checkout'
    )
    self.patcher_llvm = patch('code_coverage_installer.verify_llvm_tools')
    self.patcher_recipes = patch('code_coverage_installer.verify_recipes')
    self.patcher_service = patch('code_coverage_installer.verify_service')
    self.patcher_setup = patch('code_coverage_installer.setup_infra')

    self.mock_checkout = self.patcher_checkout.start()
    self.mock_llvm = self.patcher_llvm.start()
    self.mock_recipes = self.patcher_recipes.start()
    self.mock_service = self.patcher_service.start()
    self.mock_gemini = self.patcher_gemini.start()
    self.mock_setup = self.patcher_setup.start()
    self.mock_exit = self.patcher_exit.start()
    self.patcher_argv.start()

    self.addCleanup(patch.stopall)

  def test_main_checkout_failed(self) -> None:
    """Verifies main() exits with status 1 if Chromium checkout check fails."""
    self.mock_checkout.return_value = False
    with self.assertRaises(SystemExit):
      code_coverage_installer.main()
    self.mock_exit.assert_called_once_with(1)

  def test_main_llvm_failed(self) -> None:
    """Verifies main() exits with status 1 if LLVM tools check fails."""
    self.mock_checkout.return_value = True
    self.mock_llvm.return_value = False
    with self.assertRaises(SystemExit):
      code_coverage_installer.main()
    self.mock_exit.assert_called_once_with(1)

  def test_main_already_fully_set_up(self) -> None:
    """Verifies main() succeeds immediately without setup when checks pass."""
    self.mock_checkout.return_value = True
    self.mock_llvm.return_value = True
    self.mock_recipes.return_value = True
    self.mock_service.return_value = True
    code_coverage_installer.main()
    self.assertEqual(self.mock_exit.call_count, 0)

  def test_main_setup_needed_and_succeeds(self) -> None:
    """Verifies main() runs setup_infra when recipes/service check fails."""
    self.mock_checkout.return_value = True
    self.mock_llvm.return_value = True
    self.mock_recipes.side_effect = [False, True]
    self.mock_service.side_effect = [False, True]
    self.mock_setup.return_value = True
    code_coverage_installer.main()
    self.mock_setup.assert_called_once_with(pathlib.Path('/infra_dir'))
    self.assertEqual(self.mock_exit.call_count, 0)

  def test_main_setup_needed_but_setup_fails(self) -> None:
    """Verifies main() exits with status 1 when setup_infra fails."""
    self.mock_checkout.return_value = True
    self.mock_llvm.return_value = True
    self.mock_recipes.return_value = False
    self.mock_service.return_value = False
    self.mock_setup.return_value = False
    with self.assertRaises(SystemExit):
      code_coverage_installer.main()
    self.mock_setup.assert_called_once_with(pathlib.Path('/infra_dir'))
    self.mock_exit.assert_called_once_with(1)

  def test_main_setup_succeeds_but_re_verification_fails(self) -> None:
    """Verifies main() exits with status 1 if re-verification fails."""
    self.mock_checkout.return_value = True
    self.mock_llvm.return_value = True
    self.mock_recipes.side_effect = [False, False]
    self.mock_service.side_effect = [False, True]
    self.mock_setup.return_value = True
    with self.assertRaises(SystemExit):
      code_coverage_installer.main()
    self.mock_setup.assert_called_once_with(pathlib.Path('/infra_dir'))
    self.mock_exit.assert_called_once_with(1)


if __name__ == '__main__':
  unittest.main()