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

# pylint: disable=protected-access

import os
import sys
import unittest
from unittest import mock

# vpython-provided modules
# pylint: disable=import-error
from pyfakefs import fake_filesystem_unittest
# pylint: enable=import-error

# pylint: disable=wrong-import-position
sys.path.insert(0,
                os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from mcp_servers import build_information
# pylint: enable=wrong-import-position

CHROMIUM_ROOT = build_information.CHROMIUM_ROOT


class GetHostOsTest(unittest.TestCase):

    @mock.patch('sys.platform', 'linux')
    def test_get_host_os_linux(self):
        """Test get_host_os on linux."""
        self.assertEqual(build_information.get_host_os(),
                         build_information.ValidOs.LINUX)

    @mock.patch('sys.platform', 'cygwin')
    def test_get_host_os_cygwin_is_linux(self):
        """Test get_host_os on cygwin returns linux."""
        self.assertEqual(build_information.get_host_os(),
                         build_information.ValidOs.LINUX)

    @mock.patch('sys.platform', 'win32')
    def test_get_host_os_win(self):
        """Test get_host_os on windows."""
        self.assertEqual(build_information.get_host_os(),
                         build_information.ValidOs.WIN)

    @mock.patch('sys.platform', 'darwin')
    def test_get_host_os_mac(self):
        """Test get_host_os on mac."""
        self.assertEqual(build_information.get_host_os(),
                         build_information.ValidOs.MAC)

    @mock.patch('sys.platform', 'freebsd')
    def test_get_host_os_unknown(self):
        """Test get_host_os on an unknown os."""
        self.assertEqual(build_information.get_host_os(),
                         build_information.ValidOs.UNKNOWN)


class GetHostArchTest(unittest.TestCase):

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.SIXTY_FOUR)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.INTEL)
    def test_get_host_arch_x64(self, _mock_arch, _mock_bits):
        """Test get_host_arch for x64."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.X64)

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.THIRTY_TWO)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.INTEL)
    def test_get_host_arch_x86(self, _mock_arch, _mock_bits):
        """Test get_host_arch for x86."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.X86)

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.SIXTY_FOUR)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.ARM)
    def test_get_host_arch_arm64(self, _mock_arch, _mock_bits):
        """Test get_host_arch for arm64."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.ARM64)

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.THIRTY_TWO)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.ARM)
    def test_get_host_arch_arm(self, _mock_arch, _mock_bits):
        """Test get_host_arch for arm."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.ARM)

    @mock.patch('mcp_servers.build_information._get_host_bits')
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.UNKNOWN)
    def test_get_host_arch_unknown_arch(self, _mock_arch, _mock_bits):
        """Test get_host_arch for unknown architecture."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.UNKNOWN)

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.UNKNOWN)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.INTEL)
    def test_get_host_arch_intel_unknown_bits(self, _mock_arch, _mock_bits):
        """Test get_host_arch for intel with unknown bitness."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.UNKNOWN)

    @mock.patch('mcp_servers.build_information._get_host_bits',
                return_value=build_information.Bitness.UNKNOWN)
    @mock.patch('mcp_servers.build_information._get_host_architecture',
                return_value=build_information.Architecture.ARM)
    def test_get_host_arch_arm_unknown_bits(self, _mock_arch, _mock_bits):
        """Test get_host_arch for arm with unknown bitness."""
        self.assertEqual(build_information.get_host_arch(),
                         build_information.ValidArch.UNKNOWN)


class GetHostArchitectureTest(unittest.TestCase):

    @mock.patch('platform.processor', return_value='GenuineIntel')
    @mock.patch('platform.machine', return_value='x86_64')
    def test_get_host_architecture_intel_x64(self, _mock_machine,
                                             _mock_processor):
        """Test _get_host_architecture for intel x64."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.INTEL)

    @mock.patch('platform.processor', return_value='GenuineIntel')
    @mock.patch('platform.machine', return_value='x86')
    def test_get_host_architecture_intel_x86(self, _mock_machine,
                                             _mock_processor):
        """Test _get_host_architecture for intel x86."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.INTEL)

    @mock.patch('platform.processor', return_value='AuthenticAMD')
    @mock.patch('platform.machine', return_value='amd64')
    def test_get_host_architecture_intel_amd64(self, _mock_machine,
                                               _mock_processor):
        """Test _get_host_architecture for intel amd64."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.INTEL)

    @mock.patch('platform.processor', return_value='Apple M1')
    @mock.patch('platform.machine', return_value='arm64')
    def test_get_host_architecture_arm_native_arm64(self, _mock_machine,
                                                    _mock_processor):
        """Test _get_host_architecture for native arm64."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.ARM)

    @mock.patch('platform.processor', return_value='ARMv7')
    @mock.patch('platform.machine', return_value='arm')
    def test_get_host_architecture_arm_native_arm(self, _mock_machine,
                                                  _mock_processor):
        """Test _get_host_architecture for native arm."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.ARM)

    @mock.patch('platform.processor', return_value='... armv8 ...')
    @mock.patch('platform.machine', return_value='x86_64')
    def test_get_host_architecture_arm_emulated_x86(self, _mock_machine,
                                                    _mock_processor):
        """Test _get_host_architecture for emulated x86 on arm."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.ARM)

    @mock.patch('platform.processor', return_value='mips')
    @mock.patch('platform.machine', return_value='mips')
    def test_get_host_architecture_unknown(self, _mock_machine,
                                           _mock_processor):
        """Test _get_host_architecture for an unknown architecture."""
        self.assertEqual(build_information._get_host_architecture(),
                         build_information.Architecture.UNKNOWN)


class GetHostBitsTest(unittest.TestCase):

    @mock.patch('sys.maxsize', 2**32 + 1)
    def test_get_host_bits_64(self):
        """Test _get_host_bits for 64-bit."""
        self.assertEqual(build_information._get_host_bits(),
                         build_information.Bitness.SIXTY_FOUR)

    @mock.patch('sys.maxsize', 2**32 - 1)
    def test_get_host_bits_32(self):
        """Test _get_host_bits for 32-bit."""
        self.assertEqual(build_information._get_host_bits(),
                         build_information.Bitness.THIRTY_TWO)


class GetAllBuildDirectoriesTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)

    def test_get_all_build_directories(self):
        """Test getting all build directories (standard and CrOS)."""
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Debug', 'args.gn'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out_cros', 'Debug', 'args.gn'))
        dirs = build_information.get_all_build_directories()
        self.assertEqual(
            set(dirs),
            {os.path.join('out', 'Debug'),
             os.path.join('out_cros', 'Debug')})


class GetValidBuildDirectoriesForConfigTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)

        # Matching dir
        self.fs.create_file(os.path.join(CHROMIUM_ROOT, 'out', 'Linux_x64',
                                         'args.gn'),
                            contents='target_os = "linux"\ntarget_cpu = "x64"')
        # Mismatching os
        self.fs.create_file(os.path.join(CHROMIUM_ROOT, 'out', 'Win_x64',
                                         'args.gn'),
                            contents='target_os = "win"\ntarget_cpu = "x64"')
        # Mismatching cpu
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Linux_arm64', 'args.gn'),
            contents='target_os = "linux"\ntarget_cpu = "arm64"')
        # No args specified (should match)
        self.fs.create_file(os.path.join(CHROMIUM_ROOT, 'out', 'Default',
                                         'args.gn'),
                            contents='is_debug = true')
        # CrOS dir that matches
        self.fs.create_file(os.path.join(CHROMIUM_ROOT, 'out_cros',
                                         'linux_x64', 'args.gn'),
                            contents='target_os = "linux"\ntarget_cpu = "x64"')
        # Dir with no args.gn
        self.fs.create_dir(os.path.join(CHROMIUM_ROOT, 'out', 'NoArgs'))

    @mock.patch('mcp_servers.build_information.get_host_arch',
                return_value='x64')
    @mock.patch('mcp_servers.build_information.get_host_os',
                return_value='linux')
    def test_get_valid_build_information(self, _, __):
        """Test getting valid build directories for a specific config."""
        dirs = build_information.get_valid_build_directories_for_config(
            'linux', 'x64')
        self.assertEqual(
            set(dirs), {
                os.path.join('out', 'Linux_x64'),
                os.path.join('out', 'Default'),
                os.path.join('out_cros', 'linux_x64')
            })


class GetValidBuildDirectoriesForCurrentHostTest(unittest.TestCase):

    @mock.patch(
        'mcp_servers.build_information.get_valid_build_directories_for_config')
    @mock.patch('mcp_servers.build_information.get_host_arch')
    @mock.patch('mcp_servers.build_information.get_host_os')
    def test_valid_host_info(self, mock_get_os, mock_get_arch,
                             mock_get_valid_dirs):
        """Test getting dirs for current host with valid host info."""
        mock_get_os.return_value = build_information.ValidOs.LINUX
        mock_get_arch.return_value = build_information.ValidArch.X64
        mock_get_valid_dirs.return_value = ['out/Release']

        result = (
            build_information.get_valid_build_directories_for_current_host())

        mock_get_valid_dirs.assert_called_once_with('linux', 'x64')
        self.assertEqual(result, ['out/Release'])

    @mock.patch('mcp_servers.build_information.get_host_arch')
    @mock.patch('mcp_servers.build_information.get_host_os')
    def test_unknown_os(self, mock_get_os, mock_get_arch):
        """Test getting dirs for host with unknown OS returns empty list."""
        mock_get_os.return_value = build_information.ValidOs.UNKNOWN
        mock_get_arch.return_value = build_information.ValidArch.X64

        result = (
            build_information.get_valid_build_directories_for_current_host())
        self.assertEqual(result, [])

    @mock.patch('mcp_servers.build_information.get_host_arch')
    @mock.patch('mcp_servers.build_information.get_host_os')
    def test_unknown_arch(self, mock_get_os, mock_get_arch):
        """Test getting dirs for host with unknown arch returns empty list."""
        mock_get_os.return_value = build_information.ValidOs.LINUX
        mock_get_arch.return_value = build_information.ValidArch.UNKNOWN

        result = (
            build_information.get_valid_build_directories_for_current_host())
        self.assertEqual(result, [])


class GetStandardBuildDirectoriesTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)

    def test_get_standard_build_directories(self):
        """Test getting standard build directories."""
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Debug', 'args.gn'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out_cros', 'Debug', 'args.gn'))
        dirs = build_information._get_standard_build_directories()
        self.assertEqual(set(dirs), {os.path.join('out', 'Debug')})


class GetCrosBuildDirectoriesTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)

    def test_get_cros_build_directories(self):
        """Test getting CrOS build directories."""
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Debug', 'args.gn'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out_cros', 'Debug', 'args.gn'))
        dirs = build_information._get_cros_build_directories()
        self.assertEqual(set(dirs), {os.path.join('out_cros', 'Debug')})


class GetBuildDirectoriesUnderDirTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)

    def test_get_build_directories_under_dir_no_directories(self):
        """Test behavior with no valid dirs."""
        self.fs.create_dir(os.path.join(CHROMIUM_ROOT, 'out'))
        self.assertEqual(
            build_information._get_build_directories_under_dir('out'), [])

    def test_get_build_directories_under_dir_multiple_valid(self):
        """Test behavior with multiple valid dirs."""
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Debug', 'args.gn'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Release', 'args.gn'))
        self.assertEqual(
            set(build_information._get_build_directories_under_dir('out')),
            {os.path.join('out', 'Debug'),
             os.path.join('out', 'Release')})

    def test_get_build_directories_under_dir_with_invalid(self):
        """Test behavior with a mix of valid/invalid dirs."""
        self.fs.create_dir(os.path.join(CHROMIUM_ROOT, 'out', 'Debug'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out', 'Release', 'args.gn'))
        self.assertEqual(
            build_information._get_build_directories_under_dir('out'),
            [os.path.join('out', 'Release')])

    def test_get_build_directories_under_dir_with_glob(self):
        """Test behavior with a glob pattern."""
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out_foo', 'Debug', 'args.gn'))
        self.fs.create_file(
            os.path.join(CHROMIUM_ROOT, 'out_bar', 'Release', 'args.gn'))
        self.fs.create_dir(os.path.join(CHROMIUM_ROOT, 'out_baz', 'Debug'))
        self.assertEqual(
            set(build_information._get_build_directories_under_dir('out_*')), {
                os.path.join('out_foo', 'Debug'),
                os.path.join('out_bar', 'Release')
            })


class DirectoryBuildsForConfigTest(fake_filesystem_unittest.TestCase):

    def setUp(self):
        self.setUpPyfakefs()
        self.fs.create_dir(CHROMIUM_ROOT)
        self.build_dir = os.path.join(CHROMIUM_ROOT, 'out', 'Release')
        self.fs.create_dir(self.build_dir)
        self.args_gn_path = os.path.join(self.build_dir, 'args.gn')

        self.os_patcher = mock.patch(
            'mcp_servers.build_information.get_host_os', return_value='linux')
        self.os_mock = self.os_patcher.start()
        self.addCleanup(self.os_patcher.stop)
        self.arch_patcher = mock.patch(
            'mcp_servers.build_information.get_host_arch', return_value='x64')
        self.arch_mock = self.arch_patcher.start()
        self.addCleanup(self.arch_patcher.stop)

    def test_no_args_gn_file(self):
        """Test directory without args.gn returns False."""
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_empty_args_gn_matching_defaults(self):
        """Test empty args.gn is true if defaults match requested config."""
        self.fs.create_file(self.args_gn_path, contents='')
        self.assertTrue(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.os_mock.assert_called_once()
        self.arch_mock.assert_called_once()

    def test_empty_args_gn_mismatching_os_default(self):
        """Test empty args.gn is false if default os mismatches."""
        self.os_mock.return_value = 'win'
        self.fs.create_file(self.args_gn_path, contents='')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.os_mock.assert_called_once()

    def test_empty_args_gn_mismatching_cpu_default(self):
        """Test empty args.gn is false if default cpu mismatches."""
        self.arch_mock.return_value = 'arm64'
        self.fs.create_file(self.args_gn_path, contents='')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.os_mock.assert_called_once()
        self.arch_mock.assert_called_once()

    def test_matching_os_and_cpu(self):
        """Test args.gn with matching os and cpu."""
        self.fs.create_file(self.args_gn_path,
                            contents='target_os = "linux"\ntarget_cpu = "x64"')
        self.assertTrue(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_mismatching_os(self):
        """Test args.gn with mismatching os."""
        self.fs.create_file(self.args_gn_path,
                            contents='target_os = "win"\ntarget_cpu = "x64"')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_mismatching_cpu(self):
        """Test args.gn with mismatching cpu."""
        self.fs.create_file(
            self.args_gn_path,
            contents='target_os = "linux"\ntarget_cpu = "arm64"')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_only_os_matching_cpu_default(self):
        """Test only os in args.gn is true if default cpu matches."""
        self.fs.create_file(self.args_gn_path, contents='target_os = "linux"')
        self.assertTrue(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.arch_mock.assert_called_once()

    def test_only_os_mismatching_cpu_default(self):
        """Test only os in args.gn is false if default cpu mismatches."""
        self.arch_mock.return_value = 'arm64'
        self.fs.create_file(self.args_gn_path, contents='target_os = "linux"')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.arch_mock.assert_called_once()

    def test_only_cpu_matching_os_default(self):
        """Test only cpu in args.gn is true if default os matches."""
        self.fs.create_file(self.args_gn_path, contents='target_cpu = "x64"')
        self.assertTrue(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.os_mock.assert_called_once()

    def test_only_cpu_mismatching_os_default(self):
        """Test only cpu in args.gn is false if default os mismatches."""
        self.os_mock.return_value = 'win'
        self.fs.create_file(self.args_gn_path, contents='target_cpu = "x64"')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))
        self.os_mock.assert_called_once()

    def test_with_import_matching(self):
        """Test matching config from an imported .gni file."""
        gni_import_path = '//build/config.gni'
        gni_path = os.path.join(CHROMIUM_ROOT, 'build', 'config.gni')
        self.fs.create_file(gni_path, contents='target_os = "linux"')
        self.fs.create_file(
            self.args_gn_path,
            contents=f'import("{gni_import_path}")\ntarget_cpu = "x64"')
        self.assertTrue(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_with_import_mismatching(self):
        """Test mismatching config from an imported .gni file."""
        gni_import_path = '//build/config.gni'
        gni_path = os.path.join(CHROMIUM_ROOT, 'build', 'config.gni')
        self.fs.create_file(gni_path, contents='target_os = "win"')
        self.fs.create_file(
            self.args_gn_path,
            contents=f'import("{gni_import_path}")\ntarget_cpu = "x64"')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_with_nonexistent_import(self):
        """Test args.gn with a non-existent import returns False."""
        self.fs.create_file(self.args_gn_path,
                            contents='import("//build/nonexistent.gni")')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))

    def test_with_malformed_file(self):
        """Test that a malformed args.gn returns False."""
        self.fs.create_file(self.args_gn_path,
                            contents='target_os = "linux"\nasdf asdf')
        self.assertFalse(
            build_information._directory_builds_for_config(
                self.build_dir, 'linux', 'x64'))


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