#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright 2019 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Unit tests for updating LLVM hashes."""


import collections
import datetime
import os
from pathlib import Path
import subprocess
import unittest
import unittest.mock as mock

import chroot
import failure_modes
import get_llvm_hash
import git
import subprocess_helpers
import test_helpers
import update_chromeos_llvm_hash


# These are unittests; protected access is OK to a point.
# pylint: disable=protected-access


class UpdateLLVMHashTest(unittest.TestCase):
    """Test class for updating LLVM hashes of packages."""

    @mock.patch.object(os.path, "realpath")
    def testDefaultCrosRootFromCrOSCheckout(self, mock_llvm_tools):
        llvm_tools_path = (
            "/path/to/cros/src/third_party/toolchain-utils/llvm_tools"
        )
        mock_llvm_tools.return_value = llvm_tools_path
        self.assertEqual(
            update_chromeos_llvm_hash.defaultCrosRoot(), Path("/path/to/cros")
        )

    @mock.patch.object(os.path, "realpath")
    def testDefaultCrosRootFromOutsideCrOSCheckout(self, mock_llvm_tools):
        mock_llvm_tools.return_value = "~/toolchain-utils/llvm_tools"
        self.assertEqual(
            update_chromeos_llvm_hash.defaultCrosRoot(),
            Path.home() / "chromiumos",
        )

    # Simulate behavior of 'os.path.isfile()' when the ebuild path to a package
    # does not exist.
    @mock.patch.object(os.path, "isfile", return_value=False)
    def testFailedToUpdateLLVMHashForInvalidEbuildPath(self, mock_isfile):
        ebuild_path = "/some/path/to/package.ebuild"
        llvm_variant = update_chromeos_llvm_hash.LLVMVariant.current
        git_hash = "a123testhash1"
        svn_version = 1000

        # Verify the exception is raised when the ebuild path does not exist.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UpdateEbuildLLVMHash(
                ebuild_path, llvm_variant, git_hash, svn_version
            )

        self.assertEqual(
            str(err.exception), "Invalid ebuild path provided: %s" % ebuild_path
        )

        mock_isfile.assert_called_once()

    # Simulate 'os.path.isfile' behavior on a valid ebuild path.
    @mock.patch.object(os.path, "isfile", return_value=True)
    def testFailedToUpdateLLVMHash(self, mock_isfile):
        # Create a temporary file to simulate an ebuild file of a package.
        with test_helpers.CreateTemporaryJsonFile() as ebuild_file:
            with open(ebuild_file, "w") as f:
                f.write(
                    "\n".join(
                        [
                            "First line in the ebuild",
                            "Second line in the ebuild",
                            "Last line in the ebuild",
                        ]
                    )
                )

            llvm_variant = update_chromeos_llvm_hash.LLVMVariant.current
            git_hash = "a123testhash1"
            svn_version = 1000

            # Verify the exception is raised when the ebuild file does not have
            # 'LLVM_HASH'.
            with self.assertRaises(ValueError) as err:
                update_chromeos_llvm_hash.UpdateEbuildLLVMHash(
                    ebuild_file, llvm_variant, git_hash, svn_version
                )

            self.assertEqual(str(err.exception), "Failed to update LLVM_HASH")

            llvm_variant = update_chromeos_llvm_hash.LLVMVariant.next

        self.assertEqual(mock_isfile.call_count, 2)

    # Simulate 'os.path.isfile' behavior on a valid ebuild path.
    @mock.patch.object(os.path, "isfile", return_value=True)
    def testFailedToUpdateLLVMNextHash(self, mock_isfile):
        # Create a temporary file to simulate an ebuild file of a package.
        with test_helpers.CreateTemporaryJsonFile() as ebuild_file:
            with open(ebuild_file, "w") as f:
                f.write(
                    "\n".join(
                        [
                            "First line in the ebuild",
                            "Second line in the ebuild",
                            "Last line in the ebuild",
                        ]
                    )
                )

            llvm_variant = update_chromeos_llvm_hash.LLVMVariant.next
            git_hash = "a123testhash1"
            svn_version = 1000

            # Verify the exception is raised when the ebuild file does not have
            # 'LLVM_NEXT_HASH'.
            with self.assertRaises(ValueError) as err:
                update_chromeos_llvm_hash.UpdateEbuildLLVMHash(
                    ebuild_file, llvm_variant, git_hash, svn_version
                )

            self.assertEqual(
                str(err.exception), "Failed to update LLVM_NEXT_HASH"
            )

        self.assertEqual(mock_isfile.call_count, 2)

    @mock.patch.object(os.path, "isfile", return_value=True)
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyStageTheEbuildForCommitForLLVMHashUpdate(
        self, mock_stage_commit_command, mock_isfile
    ):

        # Create a temporary file to simulate an ebuild file of a package.
        with test_helpers.CreateTemporaryJsonFile() as ebuild_file:
            # Updates LLVM_HASH to 'git_hash' and revision to
            # 'svn_version'.
            llvm_variant = update_chromeos_llvm_hash.LLVMVariant.current
            git_hash = "a123testhash1"
            svn_version = 1000

            with open(ebuild_file, "w") as f:
                f.write(
                    "\n".join(
                        [
                            "First line in the ebuild",
                            "Second line in the ebuild",
                            'LLVM_HASH="a12b34c56d78e90" # r500',
                            "Last line in the ebuild",
                        ]
                    )
                )

            update_chromeos_llvm_hash.UpdateEbuildLLVMHash(
                ebuild_file, llvm_variant, git_hash, svn_version
            )

            expected_file_contents = [
                "First line in the ebuild\n",
                "Second line in the ebuild\n",
                'LLVM_HASH="a123testhash1" # r1000\n',
                "Last line in the ebuild",
            ]

            # Verify the new file contents of the ebuild file match the expected file
            # contents.
            with open(ebuild_file) as new_file:
                file_contents_as_a_list = [cur_line for cur_line in new_file]
                self.assertListEqual(
                    file_contents_as_a_list, expected_file_contents
                )

        self.assertEqual(mock_isfile.call_count, 2)

        mock_stage_commit_command.assert_called_once()

    @mock.patch.object(os.path, "isfile", return_value=True)
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyStageTheEbuildForCommitForLLVMNextHashUpdate(
        self, mock_stage_commit_command, mock_isfile
    ):

        # Create a temporary file to simulate an ebuild file of a package.
        with test_helpers.CreateTemporaryJsonFile() as ebuild_file:
            # Updates LLVM_NEXT_HASH to 'git_hash' and revision to
            # 'svn_version'.
            llvm_variant = update_chromeos_llvm_hash.LLVMVariant.next
            git_hash = "a123testhash1"
            svn_version = 1000

            with open(ebuild_file, "w") as f:
                f.write(
                    "\n".join(
                        [
                            "First line in the ebuild",
                            "Second line in the ebuild",
                            'LLVM_NEXT_HASH="a12b34c56d78e90" # r500',
                            "Last line in the ebuild",
                        ]
                    )
                )

            update_chromeos_llvm_hash.UpdateEbuildLLVMHash(
                ebuild_file, llvm_variant, git_hash, svn_version
            )

            expected_file_contents = [
                "First line in the ebuild\n",
                "Second line in the ebuild\n",
                'LLVM_NEXT_HASH="a123testhash1" # r1000\n',
                "Last line in the ebuild",
            ]

            # Verify the new file contents of the ebuild file match the expected file
            # contents.
            with open(ebuild_file) as new_file:
                file_contents_as_a_list = [cur_line for cur_line in new_file]
                self.assertListEqual(
                    file_contents_as_a_list, expected_file_contents
                )

        self.assertEqual(mock_isfile.call_count, 2)

        mock_stage_commit_command.assert_called_once()

    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    @mock.patch.object(os.path, "islink", return_value=False)
    def testFailedToUprevEbuildToVersionForInvalidSymlink(
        self, mock_islink, mock_llvm_version
    ):
        symlink_path = "/path/to/chroot/package/package.ebuild"
        svn_version = 1000
        git_hash = "badf00d"
        mock_llvm_version.return_value = "1234"

        # Verify the exception is raised when a invalid symbolic link is passed in.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UprevEbuildToVersion(
                symlink_path, svn_version, git_hash
            )

        self.assertEqual(
            str(err.exception), "Invalid symlink provided: %s" % symlink_path
        )

        mock_islink.assert_called_once()
        mock_llvm_version.assert_not_called()

    @mock.patch.object(os.path, "islink", return_value=False)
    def testFailedToUprevEbuildSymlinkForInvalidSymlink(self, mock_islink):
        symlink_path = "/path/to/chroot/package/package.ebuild"

        # Verify the exception is raised when a invalid symbolic link is passed in.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UprevEbuildSymlink(symlink_path)

        self.assertEqual(
            str(err.exception), "Invalid symlink provided: %s" % symlink_path
        )

        mock_islink.assert_called_once()

    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    # Simulate 'os.path.islink' when a symbolic link is passed in.
    @mock.patch.object(os.path, "islink", return_value=True)
    # Simulate 'os.path.realpath' when a symbolic link is passed in.
    @mock.patch.object(os.path, "realpath", return_value=True)
    def testFailedToUprevEbuildToVersion(
        self, mock_realpath, mock_islink, mock_llvm_version
    ):
        symlink_path = "/path/to/chroot/llvm/llvm_pre123_p.ebuild"
        mock_realpath.return_value = "/abs/path/to/llvm/llvm_pre123_p.ebuild"
        git_hash = "badf00d"
        mock_llvm_version.return_value = "1234"
        svn_version = 1000

        # Verify the exception is raised when the symlink does not match the
        # expected pattern
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UprevEbuildToVersion(
                symlink_path, svn_version, git_hash
            )

        self.assertEqual(str(err.exception), "Failed to uprev the ebuild.")

        mock_llvm_version.assert_called_once_with(git_hash)
        mock_islink.assert_called_once_with(symlink_path)

    # Simulate 'os.path.islink' when a symbolic link is passed in.
    @mock.patch.object(os.path, "islink", return_value=True)
    def testFailedToUprevEbuildSymlink(self, mock_islink):
        symlink_path = "/path/to/chroot/llvm/llvm_pre123_p.ebuild"

        # Verify the exception is raised when the symlink does not match the
        # expected pattern
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UprevEbuildSymlink(symlink_path)

        self.assertEqual(str(err.exception), "Failed to uprev the symlink.")

        mock_islink.assert_called_once_with(symlink_path)

    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    @mock.patch.object(os.path, "islink", return_value=True)
    @mock.patch.object(os.path, "realpath")
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyUprevEbuildToVersionLLVM(
        self, mock_command_output, mock_realpath, mock_islink, mock_llvm_version
    ):
        symlink = "/path/to/llvm/llvm-12.0_pre3_p2-r10.ebuild"
        ebuild = "/abs/path/to/llvm/llvm-12.0_pre3_p2.ebuild"
        mock_realpath.return_value = ebuild
        git_hash = "badf00d"
        mock_llvm_version.return_value = "1234"
        svn_version = 1000

        update_chromeos_llvm_hash.UprevEbuildToVersion(
            symlink, svn_version, git_hash
        )

        mock_llvm_version.assert_called_once_with(git_hash)

        mock_islink.assert_called()

        mock_realpath.assert_called_once_with(symlink)

        mock_command_output.assert_called()

        # Verify commands
        symlink_dir = os.path.dirname(symlink)
        timestamp = datetime.datetime.today().strftime("%Y%m%d")
        new_ebuild = (
            "/abs/path/to/llvm/llvm-1234.0_pre1000_p%s.ebuild" % timestamp
        )
        new_symlink = new_ebuild[: -len(".ebuild")] + "-r1.ebuild"

        expected_cmd = ["git", "-C", symlink_dir, "mv", ebuild, new_ebuild]
        self.assertEqual(
            mock_command_output.call_args_list[0], mock.call(expected_cmd)
        )

        expected_cmd = ["ln", "-s", "-r", new_ebuild, new_symlink]
        self.assertEqual(
            mock_command_output.call_args_list[1], mock.call(expected_cmd)
        )

        expected_cmd = ["git", "-C", symlink_dir, "add", new_symlink]
        self.assertEqual(
            mock_command_output.call_args_list[2], mock.call(expected_cmd)
        )

        expected_cmd = ["git", "-C", symlink_dir, "rm", symlink]
        self.assertEqual(
            mock_command_output.call_args_list[3], mock.call(expected_cmd)
        )

    @mock.patch.object(
        chroot,
        "GetChrootEbuildPaths",
        return_value=["/chroot/path/test.ebuild"],
    )
    @mock.patch.object(subprocess, "check_output", return_value="")
    def testManifestUpdate(self, mock_subprocess, mock_ebuild_paths):
        manifest_packages = ["sys-devel/llvm"]
        chroot_path = "/path/to/chroot"
        update_chromeos_llvm_hash.UpdateManifests(
            manifest_packages, chroot_path
        )

        args = mock_subprocess.call_args[0][-1]
        manifest_cmd = [
            "cros_sdk",
            "--",
            "ebuild",
            "/chroot/path/test.ebuild",
            "manifest",
        ]
        self.assertEqual(args, manifest_cmd)
        mock_ebuild_paths.assert_called_once()

    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    @mock.patch.object(os.path, "islink", return_value=True)
    @mock.patch.object(os.path, "realpath")
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyUprevEbuildToVersionNonLLVM(
        self, mock_command_output, mock_realpath, mock_islink, mock_llvm_version
    ):
        symlink = (
            "/abs/path/to/compiler-rt/compiler-rt-12.0_pre314159265-r4.ebuild"
        )
        ebuild = "/abs/path/to/compiler-rt/compiler-rt-12.0_pre314159265.ebuild"
        mock_realpath.return_value = ebuild
        mock_llvm_version.return_value = "1234"
        svn_version = 1000
        git_hash = "5678"

        update_chromeos_llvm_hash.UprevEbuildToVersion(
            symlink, svn_version, git_hash
        )

        mock_islink.assert_called()

        mock_realpath.assert_called_once_with(symlink)

        mock_llvm_version.assert_called_once_with(git_hash)

        mock_command_output.assert_called()

        # Verify commands
        symlink_dir = os.path.dirname(symlink)
        new_ebuild = (
            "/abs/path/to/compiler-rt/compiler-rt-1234.0_pre1000.ebuild"
        )
        new_symlink = new_ebuild[: -len(".ebuild")] + "-r1.ebuild"

        expected_cmd = ["git", "-C", symlink_dir, "mv", ebuild, new_ebuild]
        self.assertEqual(
            mock_command_output.call_args_list[0], mock.call(expected_cmd)
        )

        expected_cmd = ["ln", "-s", "-r", new_ebuild, new_symlink]
        self.assertEqual(
            mock_command_output.call_args_list[1], mock.call(expected_cmd)
        )

        expected_cmd = ["git", "-C", symlink_dir, "add", new_symlink]
        self.assertEqual(
            mock_command_output.call_args_list[2], mock.call(expected_cmd)
        )

        expected_cmd = ["git", "-C", symlink_dir, "rm", symlink]
        self.assertEqual(
            mock_command_output.call_args_list[3], mock.call(expected_cmd)
        )

    @mock.patch.object(os.path, "islink", return_value=True)
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyUprevEbuildSymlink(
        self, mock_command_output, mock_islink
    ):
        symlink_to_uprev = "/symlink/to/package-r1.ebuild"

        update_chromeos_llvm_hash.UprevEbuildSymlink(symlink_to_uprev)

        mock_islink.assert_called_once_with(symlink_to_uprev)

        mock_command_output.assert_called_once()

    # Simulate behavior of 'os.path.isdir()' when the path to the repo is not a

    # directory.

    @mock.patch.object(chroot, "GetChrootEbuildPaths")
    @mock.patch.object(chroot, "ConvertChrootPathsToAbsolutePaths")
    def testExceptionRaisedWhenCreatingPathDictionaryFromPackages(
        self, mock_chroot_paths_to_symlinks, mock_get_chroot_paths
    ):

        chroot_path = "/some/path/to/chroot"

        package_name = "test-pckg/package"
        package_chroot_path = "/some/chroot/path/to/package-r1.ebuild"

        # Test function to simulate 'ConvertChrootPathsToAbsolutePaths' when a
        # symlink does not start with the prefix '/mnt/host/source'.
        def BadPrefixChrootPath(*args):
            assert len(args) == 2
            raise ValueError(
                "Invalid prefix for the chroot path: "
                "%s" % package_chroot_path
            )

        # Simulate 'GetChrootEbuildPaths' when valid packages are passed in.
        #
        # Returns a list of chroot paths.
        mock_get_chroot_paths.return_value = [package_chroot_path]

        # Use test function to simulate 'ConvertChrootPathsToAbsolutePaths'
        # behavior.
        mock_chroot_paths_to_symlinks.side_effect = BadPrefixChrootPath

        # Verify exception is raised when for an invalid prefix in the symlink.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.CreatePathDictionaryFromPackages(
                chroot_path, [package_name]
            )

        self.assertEqual(
            str(err.exception),
            "Invalid prefix for the chroot path: " "%s" % package_chroot_path,
        )

        mock_get_chroot_paths.assert_called_once_with(
            chroot_path, [package_name]
        )

        mock_chroot_paths_to_symlinks.assert_called_once_with(
            chroot_path, [package_chroot_path]
        )

    @mock.patch.object(chroot, "GetChrootEbuildPaths")
    @mock.patch.object(chroot, "ConvertChrootPathsToAbsolutePaths")
    @mock.patch.object(
        update_chromeos_llvm_hash, "GetEbuildPathsFromSymLinkPaths"
    )
    def testSuccessfullyCreatedPathDictionaryFromPackages(
        self,
        mock_ebuild_paths_from_symlink_paths,
        mock_chroot_paths_to_symlinks,
        mock_get_chroot_paths,
    ):

        package_chroot_path = "/mnt/host/source/src/path/to/package-r1.ebuild"

        # Simulate 'GetChrootEbuildPaths' when returning a chroot path for a valid
        # package.
        #
        # Returns a list of chroot paths.
        mock_get_chroot_paths.return_value = [package_chroot_path]

        package_symlink_path = (
            "/some/path/to/chroot/src/path/to/package-r1.ebuild"
        )

        # Simulate 'ConvertChrootPathsToAbsolutePaths' when returning a symlink to
        # a chroot path that points to a package.
        #
        # Returns a list of symlink file paths.
        mock_chroot_paths_to_symlinks.return_value = [package_symlink_path]

        chroot_package_path = "/some/path/to/chroot/src/path/to/package.ebuild"

        # Simulate 'GetEbuildPathsFromSymlinkPaths' when returning a dictionary of
        # a symlink that points to an ebuild.
        #
        # Returns a dictionary of a symlink and ebuild file path pair
        # where the key is the absolute path to the symlink of the ebuild file
        # and the value is the absolute path to the ebuild file of the package.
        mock_ebuild_paths_from_symlink_paths.return_value = {
            package_symlink_path: chroot_package_path
        }

        chroot_path = "/some/path/to/chroot"
        package_name = "test-pckg/package"

        self.assertEqual(
            update_chromeos_llvm_hash.CreatePathDictionaryFromPackages(
                chroot_path, [package_name]
            ),
            {package_symlink_path: chroot_package_path},
        )

        mock_get_chroot_paths.assert_called_once_with(
            chroot_path, [package_name]
        )

        mock_chroot_paths_to_symlinks.assert_called_once_with(
            chroot_path, [package_chroot_path]
        )

        mock_ebuild_paths_from_symlink_paths.assert_called_once_with(
            [package_symlink_path]
        )

    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyRemovedPatchesFromFilesDir(self, mock_run_cmd):
        patches_to_remove_list = [
            "/abs/path/to/filesdir/cherry/fix_output.patch",
            "/abs/path/to/filesdir/display_results.patch",
        ]

        update_chromeos_llvm_hash.RemovePatchesFromFilesDir(
            patches_to_remove_list
        )

        self.assertEqual(mock_run_cmd.call_count, 2)

    @mock.patch.object(os.path, "isfile", return_value=False)
    def testInvalidPatchMetadataFileStagedForCommit(self, mock_isfile):
        patch_metadata_path = "/abs/path/to/filesdir/PATCHES"

        # Verify the exception is raised when the absolute path to the patch
        # metadata file does not exist or is not a file.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.StagePatchMetadataFileForCommit(
                patch_metadata_path
            )

        self.assertEqual(
            str(err.exception),
            "Invalid patch metadata file provided: " "%s" % patch_metadata_path,
        )

        mock_isfile.assert_called_once()

    @mock.patch.object(os.path, "isfile", return_value=True)
    @mock.patch.object(subprocess, "check_output", return_value=None)
    def testSuccessfullyStagedPatchMetadataFileForCommit(self, mock_run_cmd, _):

        patch_metadata_path = "/abs/path/to/filesdir/PATCHES.json"

        update_chromeos_llvm_hash.StagePatchMetadataFileForCommit(
            patch_metadata_path
        )

        mock_run_cmd.assert_called_once()

    def testNoPatchResultsForCommit(self):
        package_1_patch_info_dict = {
            "applied_patches": ["display_results.patch"],
            "failed_patches": ["fixes_output.patch"],
            "non_applicable_patches": [],
            "disabled_patches": [],
            "removed_patches": [],
            "modified_metadata": None,
        }

        package_2_patch_info_dict = {
            "applied_patches": ["redirects_stdout.patch", "fix_display.patch"],
            "failed_patches": [],
            "non_applicable_patches": [],
            "disabled_patches": [],
            "removed_patches": [],
            "modified_metadata": None,
        }

        test_package_info_dict = {
            "test-packages/package1": package_1_patch_info_dict,
            "test-packages/package2": package_2_patch_info_dict,
        }

        test_commit_message = ["Updated packages"]

        self.assertListEqual(
            update_chromeos_llvm_hash.StagePackagesPatchResultsForCommit(
                test_package_info_dict, test_commit_message
            ),
            test_commit_message,
        )

    @mock.patch.object(
        update_chromeos_llvm_hash, "StagePatchMetadataFileForCommit"
    )
    @mock.patch.object(update_chromeos_llvm_hash, "RemovePatchesFromFilesDir")
    def testAddedPatchResultsForCommit(
        self, mock_remove_patches, mock_stage_patches_for_commit
    ):

        package_1_patch_info_dict = {
            "applied_patches": [],
            "failed_patches": [],
            "non_applicable_patches": [],
            "disabled_patches": ["fixes_output.patch"],
            "removed_patches": [],
            "modified_metadata": "/abs/path/to/filesdir/PATCHES.json",
        }

        package_2_patch_info_dict = {
            "applied_patches": ["fix_display.patch"],
            "failed_patches": [],
            "non_applicable_patches": [],
            "disabled_patches": [],
            "removed_patches": ["/abs/path/to/filesdir/redirect_stdout.patch"],
            "modified_metadata": "/abs/path/to/filesdir/PATCHES.json",
        }

        test_package_info_dict = {
            "test-packages/package1": package_1_patch_info_dict,
            "test-packages/package2": package_2_patch_info_dict,
        }

        test_commit_message = ["Updated packages"]

        expected_commit_messages = [
            "Updated packages",
            "\nFor the package test-packages/package1:",
            "The patch metadata file PATCHES.json was modified",
            "The following patches were disabled:",
            "fixes_output.patch",
            "\nFor the package test-packages/package2:",
            "The patch metadata file PATCHES.json was modified",
            "The following patches were removed:",
            "redirect_stdout.patch",
        ]

        self.assertListEqual(
            update_chromeos_llvm_hash.StagePackagesPatchResultsForCommit(
                test_package_info_dict, test_commit_message
            ),
            expected_commit_messages,
        )

        path_to_removed_patch = "/abs/path/to/filesdir/redirect_stdout.patch"

        mock_remove_patches.assert_called_once_with([path_to_removed_patch])

        self.assertEqual(mock_stage_patches_for_commit.call_count, 2)

    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    @mock.patch.object(
        update_chromeos_llvm_hash, "CreatePathDictionaryFromPackages"
    )
    @mock.patch.object(git, "CreateBranch")
    @mock.patch.object(update_chromeos_llvm_hash, "UpdateEbuildLLVMHash")
    @mock.patch.object(update_chromeos_llvm_hash, "UprevEbuildSymlink")
    @mock.patch.object(git, "UploadChanges")
    @mock.patch.object(git, "DeleteBranch")
    @mock.patch.object(os.path, "realpath")
    def testExceptionRaisedWhenUpdatingPackages(
        self,
        mock_realpath,
        mock_delete_repo,
        mock_upload_changes,
        mock_uprev_symlink,
        mock_update_llvm_next,
        mock_create_repo,
        mock_create_path_dict,
        mock_llvm_major_version,
    ):

        path_to_package_dir = "/some/path/to/chroot/src/path/to"
        abs_path_to_package = os.path.join(
            path_to_package_dir, "package.ebuild"
        )
        symlink_path_to_package = os.path.join(
            path_to_package_dir, "package-r1.ebuild"
        )

        mock_llvm_major_version.return_value = "1234"

        # Test function to simulate 'CreateBranch' when successfully created the
        # branch on a valid repo path.
        def SuccessfullyCreateBranchForChanges(_, branch):
            self.assertEqual(branch, "update-LLVM_NEXT_HASH-a123testhash4")

        # Test function to simulate 'UpdateEbuildLLVMHash' when successfully
        # updated the ebuild's 'LLVM_NEXT_HASH'.
        def SuccessfullyUpdatedLLVMHash(ebuild_path, _, git_hash, svn_version):
            self.assertEqual(ebuild_path, abs_path_to_package)
            self.assertEqual(git_hash, "a123testhash4")
            self.assertEqual(svn_version, 1000)

        # Test function to simulate 'UprevEbuildSymlink' when the symlink to the
        # ebuild does not have a revision number.
        def FailedToUprevEbuildSymlink(_):
            # Raises a 'ValueError' exception because the symlink did not have have a
            # revision number.
            raise ValueError("Failed to uprev the ebuild.")

        # Test function to fail on 'UploadChanges' if the function gets called
        # when an exception is raised.
        def ShouldNotExecuteUploadChanges(*args):
            # Test function should not be called (i.e. execution should resume in the
            # 'finally' block) because 'UprevEbuildSymlink' raised an
            # exception.
            assert len(args) == 3
            assert False, (
                'Failed to go to "finally" block '
                "after the exception was raised."
            )

        test_package_path_dict = {symlink_path_to_package: abs_path_to_package}

        # Simulate behavior of 'CreatePathDictionaryFromPackages()' when
        # successfully created a dictionary where the key is the absolute path to
        # the symlink of the package and value is the absolute path to the ebuild of
        # the package.
        mock_create_path_dict.return_value = test_package_path_dict

        # Use test function to simulate behavior.
        mock_create_repo.side_effect = SuccessfullyCreateBranchForChanges
        mock_update_llvm_next.side_effect = SuccessfullyUpdatedLLVMHash
        mock_uprev_symlink.side_effect = FailedToUprevEbuildSymlink
        mock_upload_changes.side_effect = ShouldNotExecuteUploadChanges
        mock_realpath.return_value = (
            "/abs/path/to/test-packages/package1.ebuild"
        )

        packages_to_update = ["test-packages/package1"]
        llvm_variant = update_chromeos_llvm_hash.LLVMVariant.next
        git_hash = "a123testhash4"
        svn_version = 1000
        chroot_path = Path("/some/path/to/chroot")
        git_hash_source = "google3"
        branch = "update-LLVM_NEXT_HASH-a123testhash4"
        extra_commit_msg = None

        # Verify exception is raised when an exception is thrown within
        # the 'try' block by UprevEbuildSymlink function.
        with self.assertRaises(ValueError) as err:
            update_chromeos_llvm_hash.UpdatePackages(
                packages=packages_to_update,
                manifest_packages=[],
                llvm_variant=llvm_variant,
                git_hash=git_hash,
                svn_version=svn_version,
                chroot_path=chroot_path,
                mode=failure_modes.FailureModes.FAIL,
                git_hash_source=git_hash_source,
                extra_commit_msg=extra_commit_msg,
            )

        self.assertEqual(str(err.exception), "Failed to uprev the ebuild.")

        mock_create_path_dict.assert_called_once_with(
            chroot_path, packages_to_update
        )

        mock_create_repo.assert_called_once_with(path_to_package_dir, branch)

        mock_update_llvm_next.assert_called_once_with(
            abs_path_to_package, llvm_variant, git_hash, svn_version
        )

        mock_uprev_symlink.assert_called_once_with(symlink_path_to_package)

        mock_upload_changes.assert_not_called()

        mock_delete_repo.assert_called_once_with(path_to_package_dir, branch)

    @mock.patch.object(update_chromeos_llvm_hash, "EnsurePackageMaskContains")
    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    @mock.patch.object(
        update_chromeos_llvm_hash, "CreatePathDictionaryFromPackages"
    )
    @mock.patch.object(git, "CreateBranch")
    @mock.patch.object(update_chromeos_llvm_hash, "UpdateEbuildLLVMHash")
    @mock.patch.object(update_chromeos_llvm_hash, "UprevEbuildSymlink")
    @mock.patch.object(git, "UploadChanges")
    @mock.patch.object(git, "DeleteBranch")
    @mock.patch.object(
        update_chromeos_llvm_hash, "UpdatePackagesPatchMetadataFile"
    )
    @mock.patch.object(
        update_chromeos_llvm_hash, "StagePatchMetadataFileForCommit"
    )
    def testSuccessfullyUpdatedPackages(
        self,
        mock_stage_patch_file,
        mock_update_package_metadata_file,
        mock_delete_repo,
        mock_upload_changes,
        mock_uprev_symlink,
        mock_update_llvm_next,
        mock_create_repo,
        mock_create_path_dict,
        mock_llvm_version,
        mock_mask_contains,
    ):

        path_to_package_dir = "/some/path/to/chroot/src/path/to"
        abs_path_to_package = os.path.join(
            path_to_package_dir, "package.ebuild"
        )
        symlink_path_to_package = os.path.join(
            path_to_package_dir, "package-r1.ebuild"
        )

        # Test function to simulate 'CreateBranch' when successfully created the
        # branch for the changes to be made to the ebuild files.
        def SuccessfullyCreateBranchForChanges(_, branch):
            self.assertEqual(branch, "update-LLVM_NEXT_HASH-a123testhash5")

        # Test function to simulate 'UploadChanges' after a successfull update of
        # 'LLVM_NEXT_HASH" of the ebuild file.
        def SuccessfullyUpdatedLLVMHash(ebuild_path, _, git_hash, svn_version):
            self.assertEqual(
                ebuild_path, "/some/path/to/chroot/src/path/to/package.ebuild"
            )
            self.assertEqual(git_hash, "a123testhash5")
            self.assertEqual(svn_version, 1000)

        # Test function to simulate 'UprevEbuildSymlink' when successfully
        # incremented the revision number by 1.
        def SuccessfullyUprevedEbuildSymlink(symlink_path):
            self.assertEqual(
                symlink_path,
                "/some/path/to/chroot/src/path/to/package-r1.ebuild",
            )

        # Test function to simulate 'UpdatePackagesPatchMetadataFile()' when the
        # patch results contains a disabled patch in 'disable_patches' mode.
        def RetrievedPatchResults(chroot_path, svn_version, packages, mode):

            self.assertEqual(chroot_path, Path("/some/path/to/chroot"))
            self.assertEqual(svn_version, 1000)
            self.assertListEqual(packages, ["path/to"])
            self.assertEqual(mode, failure_modes.FailureModes.DISABLE_PATCHES)

            patch_metadata_file = "PATCHES.json"
            PatchInfo = collections.namedtuple(
                "PatchInfo",
                [
                    "applied_patches",
                    "failed_patches",
                    "non_applicable_patches",
                    "disabled_patches",
                    "removed_patches",
                    "modified_metadata",
                ],
            )

            package_patch_info = PatchInfo(
                applied_patches=["fix_display.patch"],
                failed_patches=["fix_stdout.patch"],
                non_applicable_patches=[],
                disabled_patches=["fix_stdout.patch"],
                removed_patches=[],
                modified_metadata="/abs/path/to/filesdir/%s"
                % patch_metadata_file,
            )

            package_info_dict = {"path/to": package_patch_info._asdict()}

            # Returns a dictionary where the key is the package and the value is a
            # dictionary that contains information about the package's patch results
            # produced by the patch manager.
            return package_info_dict

        # Test function to simulate 'UploadChanges()' when successfully created a
        # commit for the changes made to the packages and their patches and
        # retrieved the change list of the commit.
        def SuccessfullyUploadedChanges(*args):
            assert len(args) == 3
            commit_url = "https://some_name/path/to/commit/+/12345"
            return git.CommitContents(url=commit_url, cl_number=12345)

        test_package_path_dict = {symlink_path_to_package: abs_path_to_package}

        # Simulate behavior of 'CreatePathDictionaryFromPackages()' when
        # successfully created a dictionary where the key is the absolute path to
        # the symlink of the package and value is the absolute path to the ebuild of
        # the package.
        mock_create_path_dict.return_value = test_package_path_dict

        # Use test function to simulate behavior.
        mock_create_repo.side_effect = SuccessfullyCreateBranchForChanges
        mock_update_llvm_next.side_effect = SuccessfullyUpdatedLLVMHash
        mock_uprev_symlink.side_effect = SuccessfullyUprevedEbuildSymlink
        mock_update_package_metadata_file.side_effect = RetrievedPatchResults
        mock_upload_changes.side_effect = SuccessfullyUploadedChanges
        mock_llvm_version.return_value = "1234"
        mock_mask_contains.reurn_value = None

        packages_to_update = ["test-packages/package1"]
        llvm_variant = update_chromeos_llvm_hash.LLVMVariant.next
        git_hash = "a123testhash5"
        svn_version = 1000
        chroot_path = Path("/some/path/to/chroot")
        git_hash_source = "tot"
        branch = "update-LLVM_NEXT_HASH-a123testhash5"
        extra_commit_msg = "\ncommit-message-end"

        change_list = update_chromeos_llvm_hash.UpdatePackages(
            packages=packages_to_update,
            manifest_packages=[],
            llvm_variant=llvm_variant,
            git_hash=git_hash,
            svn_version=svn_version,
            chroot_path=chroot_path,
            mode=failure_modes.FailureModes.DISABLE_PATCHES,
            git_hash_source=git_hash_source,
            extra_commit_msg=extra_commit_msg,
        )

        self.assertEqual(
            change_list.url, "https://some_name/path/to/commit/+/12345"
        )

        self.assertEqual(change_list.cl_number, 12345)

        mock_create_path_dict.assert_called_once_with(
            chroot_path, packages_to_update
        )

        mock_create_repo.assert_called_once_with(path_to_package_dir, branch)

        mock_update_llvm_next.assert_called_once_with(
            abs_path_to_package, llvm_variant, git_hash, svn_version
        )

        mock_uprev_symlink.assert_called_once_with(symlink_path_to_package)

        mock_mask_contains.assert_called_once_with(chroot_path, git_hash)

        expected_commit_messages = [
            "llvm-next/tot: upgrade to a123testhash5 (r1000)\n",
            "The following packages have been updated:",
            "path/to",
            "\nFor the package path/to:",
            "The patch metadata file PATCHES.json was modified",
            "The following patches were disabled:",
            "fix_stdout.patch",
            "\ncommit-message-end",
        ]

        mock_update_package_metadata_file.assert_called_once()

        mock_stage_patch_file.assert_called_once_with(
            "/abs/path/to/filesdir/PATCHES.json"
        )

        mock_upload_changes.assert_called_once_with(
            path_to_package_dir, branch, expected_commit_messages
        )

        mock_delete_repo.assert_called_once_with(path_to_package_dir, branch)

    @mock.patch.object(subprocess, "check_output", return_value=None)
    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    def testEnsurePackageMaskContainsExisting(
        self, mock_llvm_version, mock_git_add
    ):
        chroot_path = "absolute/path/to/chroot"
        git_hash = "badf00d"
        mock_llvm_version.return_value = "1234"
        with mock.patch(
            "update_chromeos_llvm_hash.open",
            mock.mock_open(read_data="\n=sys-devel/llvm-1234.0_pre*\n"),
            create=True,
        ) as mock_file:
            update_chromeos_llvm_hash.EnsurePackageMaskContains(
                chroot_path, git_hash
            )
            handle = mock_file()
            handle.write.assert_not_called()
        mock_llvm_version.assert_called_once_with(git_hash)

        overlay_dir = (
            "absolute/path/to/chroot/src/third_party/chromiumos-overlay"
        )
        mask_path = overlay_dir + "/profiles/targets/chromeos/package.mask"
        mock_git_add.assert_called_once_with(
            ["git", "-C", overlay_dir, "add", mask_path]
        )

    @mock.patch.object(subprocess, "check_output", return_value=None)
    @mock.patch.object(get_llvm_hash, "GetLLVMMajorVersion")
    def testEnsurePackageMaskContainsNotExisting(
        self, mock_llvm_version, mock_git_add
    ):
        chroot_path = "absolute/path/to/chroot"
        git_hash = "badf00d"
        mock_llvm_version.return_value = "1234"
        with mock.patch(
            "update_chromeos_llvm_hash.open",
            mock.mock_open(read_data="nothing relevant"),
            create=True,
        ) as mock_file:
            update_chromeos_llvm_hash.EnsurePackageMaskContains(
                chroot_path, git_hash
            )
            handle = mock_file()
            handle.write.assert_called_once_with(
                "=sys-devel/llvm-1234.0_pre*\n"
            )
        mock_llvm_version.assert_called_once_with(git_hash)

        overlay_dir = (
            "absolute/path/to/chroot/src/third_party/chromiumos-overlay"
        )
        mask_path = overlay_dir + "/profiles/targets/chromeos/package.mask"
        mock_git_add.assert_called_once_with(
            ["git", "-C", overlay_dir, "add", mask_path]
        )


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