#!/usr/bin/env vpython3
"""Tests for split_cl."""

import os
import sys
import unittest
from unittest import mock

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

import split_cl
import gclient_utils


class SplitClTest(unittest.TestCase):
    @property
    def _input_dir(self):
        base = os.path.splitext(os.path.abspath(__file__))[0]
        # Here _testMethodName is a string like "testCmdAssemblyFound"
        # If the test doesn't have its own subdirectory, it uses a common one
        path = os.path.join(base + ".inputs", self._testMethodName)
        if not os.path.isdir(path):
            path = os.path.join(base + ".inputs", "commonFiles")
        return path

    def testAddUploadedByGitClSplitToDescription(self):
        description = """Convert use of X to Y in $description

<add some background about this conversion for the reviewers>

"""
        footers = "Bug: 12345"

        added_line = "This CL was uploaded by git cl split."
        experimental_lines = (
            "This CL was uploaded by an experimental version "
            "of git cl split\n"
            "(https://crbug.com/389069356)."
        )

        # Description without footers
        self.assertEqual(
            split_cl.AddUploadedByGitClSplitToDescription(description),
            description + added_line,
        )

        # Description with footers
        self.assertEqual(
            split_cl.AddUploadedByGitClSplitToDescription(
                description + footers
            ),
            description + added_line + "\n\n" + footers,
        )

        # Description with footers and experimental flag
        self.assertEqual(
            split_cl.AddUploadedByGitClSplitToDescription(
                description + footers, True
            ),
            description + experimental_lines + "\n\n" + footers,
        )

    @mock.patch("split_cl.EmitWarning")
    def testFormatDescriptionOrComment(self, mock_emit_warning):
        description = "Converted use of X to Y in $description."

        # One directory
        self.assertEqual(
            split_cl.FormatDescriptionOrComment(
                description, split_cl.FormatDirectoriesForPrinting(["foo"])
            ),
            "Converted use of X to Y in foo.",
        )

        # Many directories
        self.assertEqual(
            split_cl.FormatDescriptionOrComment(
                description,
                split_cl.FormatDirectoriesForPrinting(["foo", "bar"]),
            ),
            "Converted use of X to Y in ['foo', 'bar'].",
        )

        mock_emit_warning.assert_not_called()

        description_deprecated = "Converted use of X to Y in $directory."

        # Make sure we emit a deprecation warning if the old format is used
        self.assertEqual(
            split_cl.FormatDescriptionOrComment(
                description_deprecated,
                split_cl.FormatDirectoriesForPrinting([]),
            ),
            "Converted use of X to Y in [].",
        )

        mock_emit_warning.assert_called_once()

    def GetDirectoryBaseName(self, file_path):
        return os.path.basename(os.path.dirname(file_path))

    def MockSuggestOwners(self, paths, exclude=None):
        if not paths:
            return ["superowner"]
        return self.GetDirectoryBaseName(paths[0]).split(",")

    def MockIsFile(self, file_path):
        if os.path.basename(file_path) == "OWNERS":
            return "owner" in self.GetDirectoryBaseName(file_path)

        return True

    @mock.patch("os.path.isfile")
    def testSelectReviewersForFiles(self, mock_is_file):
        mock_is_file.side_effect = self.MockIsFile
        owners_client = mock.Mock(
            SuggestOwners=self.MockSuggestOwners, EVERYONE="*"
        )
        cl = mock.Mock(owners_client=owners_client)

        files = [
            ("M", os.path.join("foo", "owner1,owner2", "a.txt")),
            ("M", os.path.join("foo", "owner1,owner2", "b.txt")),
            ("M", os.path.join("bar", "owner1,owner2", "c.txt")),
            ("M", os.path.join("bax", "owner2", "d.txt")),
            ("M", os.path.join("baz", "owner3", "e.txt")),
        ]

        files_split_by_reviewers = split_cl.SelectReviewersForFiles(
            cl, "author", files, 0, ""
        )

        self.assertEqual(3, len(files_split_by_reviewers.keys()))
        info1 = files_split_by_reviewers[tuple(["owner1", "owner2"])]
        self.assertEqual(
            info1.files,
            [
                ("M", os.path.join("foo", "owner1,owner2", "a.txt")),
                ("M", os.path.join("foo", "owner1,owner2", "b.txt")),
                ("M", os.path.join("bar", "owner1,owner2", "c.txt")),
            ],
        )
        self.assertEqual(
            info1.owners_directories, ["foo/owner1,owner2", "bar/owner1,owner2"]
        )
        info2 = files_split_by_reviewers[tuple(["owner2"])]
        self.assertEqual(
            info2.files, [("M", os.path.join("bax", "owner2", "d.txt"))]
        )
        self.assertEqual(info2.owners_directories, ["bax/owner2"])
        info3 = files_split_by_reviewers[tuple(["owner3"])]
        self.assertEqual(
            info3.files, [("M", os.path.join("baz", "owner3", "e.txt"))]
        )
        self.assertEqual(info3.owners_directories, ["baz/owner3"])

    class UploadClTester:
        """Sets up test environment for testing split_cl.UploadCl()"""

        def __init__(self, test):
            self.mock_git_branches = self.StartPatcher(
                "git_common.branches", test
            )
            self.mock_git_branches.return_value = []
            self.mock_git_current_branch = self.StartPatcher(
                "git_common.current_branch", test
            )
            self.mock_git_current_branch.return_value = "branch_to_upload"
            self.mock_git_run = self.StartPatcher("git_common.run", test)
            self.mock_temporary_file = self.StartPatcher(
                "gclient_utils.temporary_file", test
            )
            self.mock_temporary_file().__enter__.return_value = (
                "temporary_file0"
            )
            self.mock_file_writer = self.StartPatcher(
                "gclient_utils.FileWrite", test
            )

        def StartPatcher(self, target, test):
            patcher = mock.patch(target)
            test.addCleanup(patcher.stop)
            return patcher.start()

        def DoUploadCl(self, description, files, reviewers, cmd_upload):
            split_cl.UploadCl(
                "branch_to_upload",
                "upstream_branch",
                description,
                files,
                "description",
                "splitting_file.txt",
                None,
                reviewers,
                mock.Mock(),
                cmd_upload,
                True,
                True,
                "topic",
                os.path.sep,
            )

    def testUploadCl(self):
        """Tests commands run by UploadCl."""

        upload_cl_tester = self.UploadClTester(self)

        description = split_cl.FormatDirectoriesForPrinting(["dir0"])
        files = [
            ("M", os.path.join("bar", "a.cc")),
            ("D", os.path.join("foo", "b.cc")),
        ]
        reviewers = {"reviewer1@gmail.com", "reviewer2@gmail.com"}
        mock_cmd_upload = mock.Mock()
        upload_cl_tester.DoUploadCl(
            description, files, reviewers, mock_cmd_upload
        )

        abs_repository_path = os.path.abspath(os.path.sep)
        mock_git_run = upload_cl_tester.mock_git_run
        self.assertEqual(mock_git_run.call_count, 4)
        mock_git_run.assert_has_calls(
            [
                mock.call(
                    "checkout",
                    "-t",
                    "upstream_branch",
                    "-b",
                    split_cl.CreateBranchName("branch_to_upload", files),
                ),
                mock.call(
                    "rm", os.path.join(abs_repository_path, "foo", "b.cc")
                ),
                mock.call(
                    "checkout",
                    "branch_to_upload",
                    "--",
                    os.path.join(abs_repository_path, "bar", "a.cc"),
                ),
                mock.call("commit", "-F", "temporary_file0"),
            ]
        )

        expected_upload_args = [
            "-f",
            "-r",
            "reviewer1@gmail.com,reviewer2@gmail.com",
            "--cq-dry-run",
            "--send-mail",
            "--enable-auto-submit",
            "--topic=topic",
        ]
        mock_cmd_upload.assert_called_once_with(expected_upload_args)

    def testDontUploadClIfBranchAlreadyExists(self):
        """Tests that a CL is not uploaded if split branch already exists"""

        upload_cl_tester = self.UploadClTester(self)

        description = split_cl.FormatDirectoriesForPrinting(["dir0"])
        files = [
            ("M", os.path.join("bar", "a.cc")),
            ("D", os.path.join("foo", "b.cc")),
        ]
        reviewers = {"reviewer1@gmail.com"}
        mock_cmd_upload = mock.Mock()
        upload_cl_tester.mock_git_branches.return_value = [
            "branch0",
            split_cl.CreateBranchName("branch_to_upload", files),
        ]
        upload_cl_tester.DoUploadCl(
            description, files, reviewers, mock_cmd_upload
        )

        upload_cl_tester.mock_git_run.assert_not_called()
        mock_cmd_upload.assert_not_called()

    @mock.patch("gclient_utils.AskForData")
    def testCheckDescriptionBugLink(self, mock_ask_for_data):
        # Description contains bug link.
        self.assertTrue(split_cl.CheckDescriptionBugLink("Bug:1234"))
        self.assertEqual(mock_ask_for_data.call_count, 0)

        # Description does not contain bug link. User does not enter 'y' when
        # prompted.
        mock_ask_for_data.reset_mock()
        mock_ask_for_data.return_value = "m"
        self.assertFalse(split_cl.CheckDescriptionBugLink("Description"))
        self.assertEqual(mock_ask_for_data.call_count, 1)

        # Description does not contain bug link. User enters 'y' when prompted.
        mock_ask_for_data.reset_mock()
        mock_ask_for_data.return_value = "y"
        self.assertTrue(split_cl.CheckDescriptionBugLink("Description"))
        self.assertEqual(mock_ask_for_data.call_count, 1)

    @mock.patch("gclient_utils.FileRead", return_value="Description")
    def testLoadDescription(self, mock_file_read):
        # No description provided, use the dummy:
        self.assertTrue(
            split_cl.LoadDescription(None, True).startswith("Dummy")
        )
        self.assertEqual(mock_file_read.call_count, 0)

        # No description provided during a real run
        self.assertRaises(ValueError, split_cl.LoadDescription, None, False)
        self.assertEqual(mock_file_read.call_count, 0)

        # Description file provided, load it regardless of dry run
        self.assertEqual(
            split_cl.LoadDescription("SomeFile.txt", False), "Description"
        )
        self.assertEqual(mock_file_read.call_count, 1)

        mock_file_read.reset_mock()
        self.assertEqual(
            split_cl.LoadDescription("SomeFile.txt", True), "Description"
        )
        self.assertEqual(mock_file_read.call_count, 1)

    class SplitClTester:
        """Sets up test environment for testing split_cl.SplitCl()"""

        def __init__(self, test):
            self.mocks = []
            self.mock_file_read = self.StartPatcher(
                "gclient_utils.FileRead",
                test,
                return_value="Non-dummy description\nBug: 1243",
            )
            self.mock_in_git_repo = self.StartPatcher(
                "split_cl.EnsureInGitRepository", test
            )
            self.mock_git_status = self.StartPatcher(
                "scm.GIT.CaptureStatus", test
            )
            self.mock_git_run = self.StartPatcher("git_common.run", test)
            self.mock_git_current_branch = self.StartPatcher(
                "git_common.current_branch",
                test,
                return_value="branch_to_upload",
            )
            self.mock_git_branches = self.StartPatcher(
                "git_common.branches", test
            )
            self.mock_git_upstream = self.StartPatcher(
                "git_common.upstream", test, return_value="upstream_branch"
            )
            self.mock_get_reviewers = self.StartPatcher(
                "split_cl.SelectReviewersForFiles", test
            )
            self.mock_ask_for_data = self.StartPatcher(
                "gclient_utils.AskForData", test
            )
            self.mock_print_cl_info = self.StartPatcher(
                "split_cl.PrintClInfo", test
            )
            self.mock_print_summary = self.StartPatcher(
                "split_cl.PrintSummary", test
            )
            self.mock_upload_cl = self.StartPatcher("split_cl.UploadCl", test)
            self.mock_save_splitting = self.StartPatcher(
                "split_cl.SaveSplittingToTempFile", test
            )
            # Suppress output for cleaner tests
            self.mock_emit = self.StartPatcher("split_cl.Emit", test)

        def StartPatcher(self, target, test, **kwargs):
            patcher = mock.patch(target, **kwargs)
            test.addCleanup(patcher.stop)
            m = patcher.start()
            self.mocks.append(m)
            return m

        def ResetMocks(self):
            for m in self.mocks:
                m.reset_mock()

        def DoSplitCl(
            self,
            description_file,
            dry_run,
            summarize,
            reviewers_override,
            files_split_by_reviewers,
            proceed_response,
        ):
            all_files = [v.files for v in files_split_by_reviewers.values()]
            all_files_flattened = [
                file for files in all_files for file in files
            ]

            self.mock_git_status.return_value = all_files_flattened
            self.mock_get_reviewers.return_value = files_split_by_reviewers
            self.mock_ask_for_data.return_value = proceed_response

            split_cl.SplitCl(
                description_file,
                None,
                mock.Mock(),
                mock.Mock(),
                dry_run,
                summarize,
                reviewers_override,
                False,
                False,
                None,
                None,
                None,
                None,
                None,
                None,
            )

    # Save for re-use
    files_split_by_reviewers = {
        ("a@example.com",): split_cl.FilesAndOwnersDirectory(
            [
                ("M", "a/b/foo.cc"),
                ("M", "d/e/bar.h"),
            ],
            [],
        ),
        ("b@example.com",): split_cl.FilesAndOwnersDirectory(
            [
                ("A", "f/g/baz.py"),
            ],
            [],
        ),
    }

    def testSplitClConfirm(self):
        split_cl_tester = self.SplitClTester(self)

        # Should prompt for confirmation and upload several times
        split_cl_tester.DoSplitCl(
            "SomeFile.txt",
            False,
            False,
            None,
            self.files_split_by_reviewers,
            "y",
        )

        split_cl_tester.mock_ask_for_data.assert_called_once()
        split_cl_tester.mock_print_cl_info.assert_not_called()
        self.assertEqual(
            split_cl_tester.mock_upload_cl.call_count,
            len(self.files_split_by_reviewers),
        )

        split_cl_tester.ResetMocks()
        # Should prompt for confirmation and not upload
        split_cl_tester.DoSplitCl(
            "SomeFile.txt",
            False,
            False,
            None,
            self.files_split_by_reviewers,
            "f",
        )

        split_cl_tester.mock_ask_for_data.assert_called_once()
        split_cl_tester.mock_print_cl_info.assert_not_called()
        split_cl_tester.mock_upload_cl.assert_not_called()

        split_cl_tester.ResetMocks()

        # Dry runs: Don't prompt, print info instead of uploading
        split_cl_tester.DoSplitCl(
            "SomeFile.txt",
            True,
            False,
            None,
            self.files_split_by_reviewers,
            "f",
        )

        split_cl_tester.mock_ask_for_data.assert_not_called()
        self.assertEqual(
            split_cl_tester.mock_print_cl_info.call_count,
            len(self.files_split_by_reviewers),
        )
        split_cl_tester.mock_print_summary.assert_not_called()
        split_cl_tester.mock_upload_cl.assert_not_called()

        split_cl_tester.ResetMocks()
        # Summarize is true: Don't prompt, emit a summary
        split_cl_tester.DoSplitCl(
            "SomeFile.txt", True, True, None, self.files_split_by_reviewers, "f"
        )

        split_cl_tester.mock_ask_for_data.assert_not_called()
        split_cl_tester.mock_print_cl_info.assert_not_called()
        split_cl_tester.mock_print_summary.assert_called_once()
        split_cl_tester.mock_upload_cl.assert_not_called()

    def testReviewerOverride(self):
        split_cl_tester = self.SplitClTester(self)

        def testOneOverride(reviewers_lst):
            split_cl_tester.DoSplitCl(
                "SomeFile.txt",
                False,
                False,
                reviewers_lst,
                self.files_split_by_reviewers,
                "y",
            )

            for call in split_cl_tester.mock_upload_cl.call_args_list:
                self.assertEqual(call.args[7], set(reviewers_lst))

            split_cl_tester.ResetMocks()

        # The 'None' case gets ample testing everywhere else
        testOneOverride([])
        testOneOverride(["a@b.com", "c@d.com"])

    def testValidateExistingBranches(self):
        """
        Make sure that we skip existing branches if they match what we intend
        to do, and fail if there are existing branches that don't match.
        """

        split_cl_tester = self.SplitClTester(self)

        # If no split branches exist, we should call upload once per CL
        split_cl_tester.mock_git_branches.return_value = [
            "branch0",
            "branch_to_upload",
        ]
        split_cl_tester.DoSplitCl(
            "SomeFile.txt",
            False,
            False,
            None,
            self.files_split_by_reviewers,
            "y",
        )
        self.assertEqual(
            split_cl_tester.mock_upload_cl.call_count,
            len(self.files_split_by_reviewers),
        )

        # TODO(389069356): We should also ensure that if there are existing
        # branches that match our current splitting, we skip them when uploading
        # Unfortunately, we're not set up to test that, so this will have to
        # wait until we've refactored SplitCl and UploadCL to be less
        # monolithic

        # If a split branch with a bad name already exists, we should fail
        split_cl_tester.mock_upload_cl.reset_mock()
        split_cl_tester.mock_git_branches.return_value = [
            "branch0",
            "branch_to_upload",
            "branch_to_upload_123456789_whatever_split",
        ]
        split_cl_tester.DoSplitCl(
            "SomeFile.txt",
            False,
            False,
            None,
            self.files_split_by_reviewers,
            "y",
        )
        split_cl_tester.mock_upload_cl.assert_not_called()

    # Tests related to saving to and loading from files
    # Sample CLInfos for testing
    CLInfo_1 = split_cl.CLInfo(
        reviewers=["a@example.com"],
        description="['chrome/browser']",
        files=[
            ("M", "chrome/browser/a.cc"),
            ("M", "chrome/browser/b.cc"),
        ],
    )

    CLInfo_2 = split_cl.CLInfo(
        reviewers=["a@example.com", "b@example.com"],
        description="['foo', 'bar/baz']",
        files=[
            ("M", "foo/browser/a.cc"),
            ("M", "bar/baz/b.cc"),
            ("D", "foo/bar/c.h"),
        ],
    )

    def testCLInfoFormat(self):
        """Make sure CLInfo printing works as expected"""

        def ReadAndStripPreamble(file):
            """Read the contents of a file and strip the automatically-added
            preamble so we can do string comparison
            """
            content = gclient_utils.FileRead(
                os.path.join(self._input_dir, file)
            )
            # Strip preamble
            stripped = [
                line
                for line in content.splitlines()
                if not line.startswith("#")
            ]
            # Strip newlines in preamble
            return "\n".join(stripped[2:])

        # Direct string comparison
        self.assertEqual(
            self.CLInfo_1.FormatForPrinting(), ReadAndStripPreamble("1_cl.txt")
        )

        self.assertEqual(
            self.CLInfo_1.FormatForPrinting()
            + "\n\n"
            + self.CLInfo_2.FormatForPrinting(),
            ReadAndStripPreamble("2_cls.txt"),
        )

    @mock.patch("split_cl.EmitWarning")
    def testParseCLInfo(self, mock_emit_warning):
        """Make sure we can parse valid files"""

        self.assertEqual(
            [self.CLInfo_1],
            split_cl.LoadSplittingFromFile(
                os.path.join(self._input_dir, "1_cl.txt"), self.CLInfo_1.files
            ),
        )
        self.assertEqual(
            [self.CLInfo_1, self.CLInfo_2],
            split_cl.LoadSplittingFromFile(
                os.path.join(self._input_dir, "2_cls.txt"),
                self.CLInfo_1.files + self.CLInfo_2.files,
            ),
        )

        # Make sure everything in this file is valid to parse
        split_cl.LoadSplittingFromFile(
            os.path.join(self._input_dir, "odd_formatting.txt"),
            self.CLInfo_1.files
            + self.CLInfo_2.files
            + [("A", "a/b/c"), ("A", "a/b/d"), ("D", "a/e")],
        )
        mock_emit_warning.assert_not_called()

    def testParseBadFiles(self):
        """Make sure we don't parse invalid files"""
        for file in os.listdir(self._input_dir):
            lines = gclient_utils.FileRead(
                os.path.join(self._input_dir, file)
            ).splitlines()
            self.assertRaises(
                split_cl.ClSplitParseError, split_cl.ParseSplittings, lines
            )

    @mock.patch("split_cl.EmitWarning")
    @mock.patch("split_cl.Emit")
    def testValidateBadFiles(self, _, mock_emit_warning):
        """Make sure we reject invalid CL lists"""
        # Warn on an empty file
        split_cl.LoadSplittingFromFile(
            os.path.join(self._input_dir, "warn_0_cls.txt"), []
        )
        mock_emit_warning.assert_called_once()
        mock_emit_warning.reset_mock()

        # Warn if reviewers don't look like emails
        split_cl.LoadSplittingFromFile(
            os.path.join(self._input_dir, "warn_bad_reviewer_email.txt"),
            [("M", "a.cc")],
        )
        self.assertEqual(mock_emit_warning.call_count, 2)
        mock_emit_warning.reset_mock()

        # Fail if a file appears in multiple CLs
        self.assertRaises(
            split_cl.ClSplitParseError,
            split_cl.LoadSplittingFromFile,
            os.path.join(self._input_dir, "error_file_in_multiple_cls.txt"),
            [
                ("M", "chrome/browser/a.cc"),
                ("M", "chrome/browser/b.cc"),
                ("M", "bar/baz/b.cc"),
                ("D", "foo/bar/c.h"),
            ],
        )

        # Fail if a file is listed that doesn't appear on disk
        self.assertRaises(
            split_cl.ClSplitParseError,
            split_cl.LoadSplittingFromFile,
            os.path.join(self._input_dir, "no_inherent_problems.txt"),
            [("M", "chrome/browser/a.cc"), ("M", "chrome/browser/b.cc")],
        )
        self.assertRaises(
            split_cl.ClSplitParseError,
            split_cl.LoadSplittingFromFile,
            os.path.join(self._input_dir, "no_inherent_problems.txt"),
            [
                ("M", "chrome/browser/a.cc"),
                ("M", "chrome/browser/b.cc"),
                ("D", "c.h"),  # Wrong action, should still error
            ],
        )

        # Warn if not all files on disk are included
        split_cl.LoadSplittingFromFile(
            os.path.join(self._input_dir, "no_inherent_problems.txt"),
            [
                ("M", "chrome/browser/a.cc"),
                ("M", "chrome/browser/b.cc"),
                ("A", "c.h"),
                ("D", "d.h"),
            ],
        )
        mock_emit_warning.assert_called_once()

    @mock.patch("split_cl.Emit")
    @mock.patch("gclient_utils.FileWrite")
    def testParsingRoundTrip(self, mock_file_write, _):
        """Make sure that if we parse a file and save the result,
        we get the same file. Only works on test files that are
        nicely formatted."""

        for file in os.listdir(self._input_dir):
            if file == "odd_formatting.txt":
                continue
            contents = gclient_utils.FileRead(
                os.path.join(self._input_dir, file)
            )
            parsed_contents = split_cl.ParseSplittings(contents.splitlines())
            split_cl.SaveSplittingToFile(parsed_contents, "file.txt")

            written_lines = [
                args[0][1] for args in mock_file_write.call_args_list
            ]

            self.assertEqual(contents, "".join(written_lines))
            mock_file_write.reset_mock()

    @mock.patch("os.path.isfile", return_value=False)
    def testDirectoryTrie(self, _):
        """
        Simple unit tests for creating and reading from a DirectoryTrie.
        """
        # The trie code uses OS paths so we need to do the same here
        path_abc = os.path.join("a", "b", "c.cc")
        path_abd = os.path.join("a", "b", "d.h")
        path_aefgh = os.path.join("a", "e", "f", "g", "h.hpp")
        path_ijk = os.path.join("i", "j", "k.cc")
        path_al = os.path.join("a", "l.cpp")
        path_top = os.path.join("top.gn")

        files = [path_abc, path_abd, path_aefgh, path_ijk, path_al, path_top]
        split_files = [file.split(os.path.sep) for file in files]

        trie = split_cl.DirectoryTrie(False)
        trie.AddFiles(split_files)

        self.assertEqual(trie.files, [path_top])
        self.assertEqual(trie.subdirectories["a"].files, [path_al])
        self.assertEqual(
            trie.subdirectories["a"].subdirectories["b"].files,
            [path_abc, path_abd],
        )
        self.assertEqual(sorted(trie.ToList()), sorted(files))

        self.assertFalse(trie.has_parent)
        self.assertFalse(trie.subdirectories["a"].has_parent)
        self.assertTrue(trie.subdirectories["a"].subdirectories["b"].has_parent)

        self.assertEqual(trie.prefix, "")
        self.assertEqual(trie.subdirectories["a"].prefix, "a")
        self.assertEqual(
            trie.subdirectories["a"].subdirectories["b"].prefix,
            os.path.join("a", "b"),
        )

    @mock.patch("os.path.isfile", return_value=False)
    def testClusterFiles(self, _):
        """
        Make sure ClusterFiles returns sensible results for some sample inputs.
        """

        def compareClusterOutput(
            clusters: list[split_cl.Bin], file_groups: list[list[str]]
        ):
            """
            Ensure that ClusterFiles grouped files the way we expected it to.
            """
            clustered_files = sorted([sorted(bin.files) for bin in clusters])
            file_groups = sorted([sorted(grp) for grp in file_groups])
            self.assertEqual(clustered_files, file_groups)

        # The clustering code uses OS paths so we need to do the same here
        path_abc = os.path.join("a", "b", "c.cc")
        path_abd = os.path.join("a", "b", "d.h")
        path_aefgh = os.path.join("a", "e", "f", "g", "h.hpp")
        path_ijk = os.path.join("i", "j", "k.cc")
        path_ilm = os.path.join("i", "l", "m.cc")
        path_an = os.path.join("a", "n.cpp")
        path_top = os.path.join("top.gn")
        files = [
            path_abc,
            path_abd,
            path_aefgh,
            path_ijk,
            path_ilm,
            path_an,
            path_top,
        ]

        def checkClustering(min_files, max_files, expected):
            clusters = split_cl.ClusterFiles(False, files, min_files, max_files)
            compareClusterOutput(clusters, expected)

        # Each file gets its own cluster
        individual_files = [[file] for file in files]
        checkClustering(1, 1, individual_files)

        # Put both entries of a/b in the same cluster, everything else alone
        ab_together = [
            [path_abc, path_abd],
            [path_aefgh],
            [path_ijk],
            [path_ilm],
            [path_an],
            [path_top],
        ]
        checkClustering(1, 2, ab_together)
        checkClustering(1, 100, ab_together)

        # Groups of 2: a/b, rest of a/, all of i/.
        a_two_groups = [
            [path_abc, path_abd],
            [path_aefgh, path_an],
            [path_ijk, path_ilm],
            [path_top],
        ]
        checkClustering(2, 2, a_two_groups)
        checkClustering(3, 3, a_two_groups)

        # Put all of a/ together and all of i/ together.
        # Don't combine top-level directories with things at the root
        by_top_level_dir = [
            [path_abc, path_abd, path_aefgh, path_an],
            [path_ijk, path_ilm],
            [path_top],
        ]
        checkClustering(3, 5, by_top_level_dir)
        checkClustering(100, 200, by_top_level_dir)


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