| #!/usr/bin/env python2 |
| # -*- coding: utf-8 -*- |
| # Copyright 2019 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for updating the LLVM next hash.""" |
| |
| from __future__ import print_function |
| |
| from pipes import quote |
| from tempfile import mkstemp |
| import mock |
| import os |
| import unittest |
| |
| from cros_utils import command_executer |
| import update_chromeos_llvm_next_hash |
| |
| |
| def CallCountsToMockFunctions(mock_function): |
| """A decorator that passes a call count to the function it decorates. |
| |
| Examples: |
| @CallCountsToMockFunctions |
| def foo(call_count): |
| return call_count |
| ... |
| ... |
| [foo(), foo(), foo()] |
| [0, 1, 2] |
| |
| NOTE: This decorator will not handle recursive functions properly. |
| """ |
| |
| counter = [0] |
| |
| def Result(*args, **kwargs): |
| ret_value = mock_function(counter[0], *args, **kwargs) |
| counter[0] += 1 |
| return ret_value |
| |
| return Result |
| |
| |
| class UpdateLLVMNextHashTest(unittest.TestCase): |
| """Test class for updating 'LLVM_NEXT_HASH' of packages.""" |
| |
| @mock.patch.object(command_executer.CommandExecuter, |
| 'ChrootRunCommandWOutput') |
| def testFailedToGetChrootPathForInvalidPackage(self, mock_chroot_command): |
| |
| # Emulate ChrootRunCommandWOutput behavior when an invalid package is |
| # passed in. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_chroot_command.return_value = (1, None, 'Invalid package provided.') |
| |
| # Verify the exception is raised when an invalid package is passed in. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.GetChrootBuildPaths( |
| '/test/chroot/path', ['test-pckg/test']) |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Failed to get chroot path for the package (test-pckg/test): ' |
| 'Invalid package provided.') |
| |
| mock_chroot_command.assert_called_once_with( |
| chromeos_root='/test/chroot/path', |
| command='equery w test-pckg/test', |
| print_to_console=False) |
| |
| @mock.patch.object(command_executer.CommandExecuter, |
| 'ChrootRunCommandWOutput') |
| def testSucceedsToGetChrootPathForPackage(self, mock_chroot_command): |
| # Emulate ChrootRunCommandWOutput behavior when a chroot path is found for |
| # a valid package. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_chroot_command.return_value = (0, '/chroot/path/to/package.ebuild\n', |
| 0) |
| |
| self.assertEqual( |
| update_chromeos_llvm_next_hash.GetChrootBuildPaths( |
| '/test/chroot/path', ['new-test/package']), |
| ['/chroot/path/to/package.ebuild']) |
| |
| mock_chroot_command.assert_called_once_with( |
| chromeos_root='/test/chroot/path', |
| command='equery w new-test/package', |
| print_to_console=False) |
| |
| def testFailedToConvertChrootPathWithInvalidPrefixToSymlinkPath(self): |
| # Verify the exception is raised when a symlink does not have the prefix |
| # '/mnt/host/source/'. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash._ConvertChrootPathsToSymLinkPaths( |
| '/path/to/chroot', ['/src/package.ebuild']) |
| |
| self.assertEqual( |
| err.exception.message, 'Invalid prefix for the chroot path: ' |
| '/src/package.ebuild') |
| |
| def testSucceedsToConvertChrootPathToSymlinkPath(self): |
| self.assertEqual( |
| update_chromeos_llvm_next_hash._ConvertChrootPathsToSymLinkPaths( |
| '/path/to/chroot', ['/mnt/host/source/src/package.ebuild']), |
| ['/path/to/chroot/src/package.ebuild']) |
| |
| @mock.patch.object(os.path, 'islink') |
| def testFailedToGetEbuildPathFromInvalidSymlink(self, mock_islink): |
| # Simulate 'os.path.islink' when a path is not a symbolic link. |
| mock_islink.return_value = False |
| |
| # Verify the exception is raised when the argument is not a symbolic link. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.GetEbuildPathsFromSymLinkPaths( |
| ['/symlink/path/src/to/package-r1.ebuild']) |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Invalid symlink provided: /symlink/path/src/to/package-r1.ebuild') |
| |
| mock_islink.assert_called_once_with( |
| '/symlink/path/src/to/package-r1.ebuild') |
| |
| @mock.patch.object(os.path, 'islink') |
| @mock.patch.object(os.path, 'realpath') |
| def testSucceedsToGetEbuildPathFromValidSymlink(self, mock_realpath, |
| mock_islink): |
| |
| # Simulate 'os.path.realpath' when a valid path is passed in. |
| mock_realpath.return_value = '/abs/path/to/src/package.ebuild' |
| |
| # Simulate 'os.path.islink' when a path is a symbolic link. |
| mock_islink.return_value = True |
| |
| self.assertEqual( |
| update_chromeos_llvm_next_hash.GetEbuildPathsFromSymLinkPaths( |
| ['/path/to/chroot/src/package-r1.ebuild']), { |
| '/path/to/chroot/src/package-r1.ebuild': |
| '/abs/path/to/src/package.ebuild' |
| }) |
| |
| mock_realpath.assert_called_once_with( |
| '/path/to/chroot/src/package-r1.ebuild') |
| |
| mock_islink.assert_called_once_with('/path/to/chroot/src/package-r1.ebuild') |
| |
| def testFailedToUpdateLLVMNextHashForInvalidEbuildPath(self): |
| # Verify the exception is raised when the ebuild path does not exist. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UpdateBuildLLVMNextHash( |
| '/some/path/to/package.ebuild', 'a123testhash1', 1000) |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Invalid ebuild path provided: /some/path/to/package.ebuild') |
| |
| @mock.patch.object(os.path, 'isfile') |
| def testFailedToUpdateLLVMNextHash(self, mock_isfile): |
| # Simulate 'os.path.isfile' behavior on a valid ebuild path. |
| mock_isfile.return_value = True |
| |
| # Create a temporary file to simulate an ebuild file of a package. |
| ebuild_file, file_path = mkstemp() |
| |
| os.write( |
| ebuild_file, '\n'.join([ |
| 'First line in the ebuild', 'Second line in the ebuild', |
| 'Last line in the ebuild' |
| ])) |
| |
| os.close(ebuild_file) |
| |
| try: |
| # Verify the exception is raised when the ebuild file does not have |
| # 'LLVM_NEXT_HASH'. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UpdateBuildLLVMNextHash( |
| file_path, 'a123testhash1', 1000) |
| |
| self.assertEqual(err.exception.message, 'Failed to update the LLVM hash.') |
| finally: |
| os.remove(file_path) |
| |
| mock_isfile.assert_called_once() |
| |
| @mock.patch.object(os.path, 'isfile') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testFailedToStageTheEbuildForCommitForLLVMNextHashUpdate( |
| self, mock_stage_commit_command, mock_isfile): |
| |
| # Simulate 'os.path.isfile' behavior on a valid ebuild path. |
| mock_isfile.return_value = True |
| |
| # Simulate 'RunCommandWOutput' when failed to stage the ebuild file for |
| # commit. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_stage_commit_command.return_value = (1, None, 'Failed to add file.') |
| |
| # Create a temporary file to simulate an ebuild file of a package. |
| ebuild_file, file_path = mkstemp() |
| |
| os.write( |
| ebuild_file, '\n'.join([ |
| 'First line in the ebuild', 'Second line in the ebuild', |
| 'LLVM_NEXT_HASH=\"a12b34c56d78e90\" # r500', |
| 'Last line in the ebuild' |
| ])) |
| |
| os.close(ebuild_file) |
| |
| try: |
| # Verify the exception is raised when staging the ebuild file. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UpdateBuildLLVMNextHash( |
| file_path, 'a123testhash1', 1000) |
| |
| self.assertEqual( |
| err.exception.message, 'Failed to stage the ebuild for commit: ' |
| 'Failed to add file.') |
| |
| 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(file_path) 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) |
| |
| finally: |
| os.remove(file_path) |
| |
| mock_isfile.assert_called_once() |
| mock_stage_commit_command.assert_called_once() |
| |
| @mock.patch.object(os.path, 'isfile') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testSuccessfullyStageTheEbuildForCommitForLLVMNextHashUpdate( |
| self, mock_stage_commit_command, mock_isfile): |
| |
| # Simulate 'os.path.isfile' behavior on a valid ebuild path. |
| mock_isfile.return_value = True |
| |
| # Simulate 'RunCommandWOutput' when successfully staged the ebuild file for |
| # commit. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_stage_commit_command.return_value = (0, None, 0) |
| |
| # Create a temporary file to simulate an ebuild file of a package. |
| ebuild_file, file_path = mkstemp() |
| |
| os.write( |
| ebuild_file, '\n'.join([ |
| 'First line in the ebuild', 'Second line in the ebuild', |
| 'LLVM_NEXT_HASH=\"a12b34c56d78e90\" # r500', |
| 'Last line in the ebuild' |
| ])) |
| |
| os.close(ebuild_file) |
| |
| try: |
| update_chromeos_llvm_next_hash.UpdateBuildLLVMNextHash( |
| file_path, 'a123testhash1', 1000) |
| |
| 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(file_path) 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) |
| |
| finally: |
| os.remove(file_path) |
| |
| mock_isfile.assert_called_once() |
| mock_stage_commit_command.assert_called_once() |
| |
| def testFailedToUprevEbuildForInvalidSymlink(self): |
| # Verify the exception is raised when a symbolic link is not passed in. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UprevEbuild('/symlink/to/package.ebuild') |
| |
| self.assertEqual(err.exception.message, |
| 'Invalid symlink provided: /symlink/to/package.ebuild') |
| |
| @mock.patch.object(os.path, 'islink') |
| def testFailedToUprevEbuild(self, mock_islink): |
| # Simulate 'os.path.islink' when a symbolic link is passed in. |
| mock_islink.return_value = True |
| |
| # Verify the exception is raised when the symlink does not have a revision |
| # number. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UprevEbuild('/symlink/to/package.ebuild') |
| |
| self.assertEqual(err.exception.message, 'Failed to uprev the ebuild.') |
| |
| mock_islink.assert_called_once_with('/symlink/to/package.ebuild') |
| |
| @mock.patch.object(os.path, 'islink') |
| @mock.patch.object(os.path, 'dirname') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testSuccessfullyUprevEbuild(self, mock_command_output, mock_dirname, |
| mock_islink): |
| |
| # Simulate 'os.path.islink' when a valid symbolic link is passed in. |
| mock_islink.return_value = True |
| |
| # Simulate 'os.path.dirname' when returning a path to the directory of a |
| # valid symbolic link. |
| mock_dirname.return_value = '/symlink/to' |
| |
| # Simulate 'RunCommandWOutput' when the symbolic link was incremented by 1 |
| # and staged for commit. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_command_output.return_value = (0, None, 0) |
| |
| update_chromeos_llvm_next_hash.UprevEbuild('/symlink/to/package-r1.ebuild') |
| |
| mock_islink.assert_called_once_with('/symlink/to/package-r1.ebuild') |
| |
| mock_dirname.assert_called_once_with('/symlink/to/package-r1.ebuild') |
| |
| mock_command_output.assert_called_once_with( |
| 'git -C /symlink/to mv ' |
| '/symlink/to/package-r1.ebuild /symlink/to/package-r2.ebuild', |
| print_to_console=False) |
| |
| def testFailedToCreateRepoForInvalidDirectoryPath(self): |
| # Verify the exception is raised when provided an invalid directory path. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash._CreateRepo('/path/to/repo', |
| 'a123testhash1') |
| |
| self.assertEqual(err.exception.message, |
| 'Invalid directory path provided: /path/to/repo') |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testFailedToCreateRepo(self, mock_command_output, mock_isdir): |
| # Simulate 'os.path.isdir' when the path to the repo is valid. |
| mock_isdir.return_value = True |
| |
| # Simulate 'RunCommandWOutput' when 'repo start' fails. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_command_output.return_value = (1, None, 'Invalid branch name.') |
| |
| # Verify exception is raised when failed to create a repo for the changes. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash._CreateRepo('/path/to/repo', |
| 'a123testhash1') |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Failed to create the repo (llvm-next-update-a123testhash1): ' |
| 'Invalid branch name.') |
| |
| mock_isdir.assert_called_once_with('/path/to/repo') |
| |
| mock_command_output.assert_called_once() |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testSuccessfullyCreatedRepo(self, mock_command_output, mock_isdir): |
| # Test function to simulate 'RunCommandWOutput' when 'repo start' succeeds. |
| def GoodRepoStart(create_repo_cmd, print_to_console): |
| self.assertEqual(create_repo_cmd.split()[-1], |
| 'llvm-next-update-a123testhash1') |
| |
| # Returns shell error code, stdout, stderr. |
| return 0, None, 0 |
| |
| # Simulate 'os.path.isdir' when a valid repo path is provided. |
| mock_isdir.return_value = True |
| |
| # Use test function to simulate 'RunCommandWOutput' behavior. |
| mock_command_output.side_effect = GoodRepoStart |
| |
| update_chromeos_llvm_next_hash._CreateRepo('/path/to/repo', 'a123testhash1') |
| |
| mock_isdir.assert_called_once_with('/path/to/repo') |
| |
| mock_command_output.assert_called_once() |
| |
| def testFailedToDeleteRepoForInvalidDirectoryPath(self): |
| # Verify the exception is raised on an invalid repo path. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash._DeleteRepo('/some/path/to/repo', |
| 'a123testhash2') |
| |
| self.assertEqual(err.exception.message, |
| 'Invalid directory path provided: /some/path/to/repo') |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testFailedToDeleteRepo(self, mock_command_output, mock_isdir): |
| # Simulate 'os.path.isdir' on a valid directory. |
| mock_isdir.return_value = True |
| |
| # Simulate 'RunCommandWOutput' when failed to delete a branch. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_command_output.return_value = (1, None, 'Invalid branch name.') |
| |
| # Verify exception is raised when failed to delete the repo. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash._DeleteRepo('/some/path/to/repo', |
| 'a123testhash2') |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Failed to delete the repo (llvm-next-update-a123testhash2): ' |
| 'Invalid branch name.') |
| |
| mock_isdir.assert_called_once_with('/some/path/to/repo') |
| |
| mock_command_output.assert_called_once() |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testSuccessfullyDeletedRepo(self, mock_command_output, mock_isdir): |
| # Test function to simulate 'RunCommandWOutput' when successfully deleted a |
| # repo. |
| def GoodRepoDelete(create_repo_cmd, print_to_console): |
| self.assertEqual(create_repo_cmd.split()[-1], |
| 'llvm-next-update-a123testhash2') |
| |
| # Returns shell error code, stdout, stderr. |
| return 0, None, 0 |
| |
| # Simulate 'os.path.isdir' on valid directory path. |
| mock_isdir.return_value = True |
| |
| # Use test function to simulate 'RunCommandWOutput' behavior. |
| mock_command_output.side_effect = GoodRepoDelete |
| |
| update_chromeos_llvm_next_hash._DeleteRepo('/some/path/to/repo', |
| 'a123testhash2') |
| |
| mock_isdir.assert_called_once_with('/some/path/to/repo') |
| |
| mock_command_output.assert_called_once() |
| |
| def testFailedToUploadChangesForInvalidPathDirectory(self): |
| # Verify exception is raised when on an invalid repo path. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UploadChanges( |
| '/some/path/to/repo', 'a123testhash3', '-m \"Test message\"') |
| |
| self.assertEqual(err.exception.message, |
| 'Invalid directory path provided: /some/path/to/repo') |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testFailedToCreateACommitForTheChanges(self, mock_command_output, |
| mock_isdir): |
| |
| # Simulate 'os.path.isdir' on a valid repo directory. |
| mock_isdir.return_value = True |
| |
| # Simulate 'RunCommandWOutput' when failed to create a commit for the |
| # changes. |
| # |
| # Returns shell error code, stdout, stderr. |
| mock_command_output.return_value = (1, None, 'Nothing to commit.') |
| |
| # Verify exception is raised when failed to create a commit. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UploadChanges( |
| '/some/path/to/repo', 'a123testhash3', '-m \"Test message\"') |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Failed to create a commit for the changes: Nothing to commit.') |
| |
| mock_isdir.assert_called_once_with('/some/path/to/repo') |
| |
| mock_command_output.assert_called_once_with( |
| 'cd /some/path/to/repo && git commit -m \"Test message\"', |
| print_to_console=False) |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testFailedToUploadChangesForReview(self, mock_command_output, mock_isdir): |
| # Test function to simulate 'RunCommandWOutput' when attempting to create |
| # a commit and upload the changes for review. |
| @CallCountsToMockFunctions |
| def MultipleCallsToUploadACommit(call_count, cmd, print_to_console): |
| # Creating a commit for the changes. |
| if call_count == 0: # first call to 'RunCommandWOutput' |
| self.assertEqual( |
| cmd, 'cd /some/path/to/repo && git commit -m \"Test message\"') |
| |
| # Returns shell error code, stdout, stderr. |
| return 0, None, 0 |
| |
| # Trying to upload the commit for review. |
| if call_count == 1: # second call to 'RunCommandWOutput' |
| # Make sure the branch name matches expected. |
| self.assertEqual(cmd.split()[-2], '--br=llvm-next-update-a123testhash3') |
| |
| # Returns shell error code, stdout, stderr. |
| return 1, None, 'Branch does not exist.' |
| |
| # Testing function was called more times than expected (2 times). |
| assert False, 'RunCommandWOutput was called more than 2 times.' |
| |
| # Simulate 'os.path.isdir' on a valid repo path. |
| mock_isdir.return_value = True |
| |
| # Use test function to simulate 'RunCommandWOutput' behavior. |
| mock_command_output.side_effect = MultipleCallsToUploadACommit |
| |
| # Verify exception is raised when failed to upload the changes for review. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UploadChanges( |
| '/some/path/to/repo', 'a123testhash3', '-m \"Test message\"') |
| |
| self.assertEqual( |
| err.exception.message, |
| 'Failed to upload changes for review: Branch does not exist.') |
| |
| mock_isdir.assert_called_once_with('/some/path/to/repo') |
| |
| self.assertEqual(mock_command_output.call_count, 2) |
| |
| @mock.patch.object(os.path, 'isdir') |
| @mock.patch.object(command_executer.CommandExecuter, 'RunCommandWOutput') |
| def testSuccessfullyUploadedChangesForReview(self, mock_command_output, |
| mock_isdir): |
| |
| # Test function to simulate 'RunCommandWOutput' when creating a commit for |
| # the changes and uploading the changes for review. |
| @CallCountsToMockFunctions |
| def MultipleCallsToUploadACommit(call_count, cmd, print_to_console): |
| # Creating a commit in the repo path. |
| if call_count == 0: # first call to 'RunCommandWOutput' |
| self.assertEqual( |
| cmd, 'cd /some/path/to/repo && git commit -m \"Test message\"') |
| |
| # Returns shell error code, stdout, stderr. |
| return 0, None, 0 |
| # Uploading the changes for review. |
| if call_count == 1: # second call to 'RunCommandWOutput' |
| # Make sure the branch name matches expected. |
| self.assertEqual(cmd.split()[-2], '--br=llvm-next-update-a123testhash3') |
| |
| # Returns shell error code, stdout, stderr. |
| return 0, None, 0 |
| |
| # Testing function was called more times than expected (2 times). |
| assert False, 'RunCommandWOutput was called more than 2 times.' |
| |
| # Simulate 'os.path.isdir' when a valid repo path is passed in. |
| mock_isdir.return_value = True |
| |
| # Use test function to simulate 'RunCommandWOutput' behavior. |
| mock_command_output.side_effect = MultipleCallsToUploadACommit |
| |
| update_chromeos_llvm_next_hash.UploadChanges( |
| '/some/path/to/repo', 'a123testhash3', '-m \"Test message\"') |
| |
| mock_isdir.assert_called_once_with('/some/path/to/repo') |
| |
| self.assertEqual(mock_command_output.call_count, 2) |
| |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'GetChrootBuildPaths') |
| @mock.patch.object(update_chromeos_llvm_next_hash, |
| '_ConvertChrootPathsToSymLinkPaths') |
| def testExceptionRaisedWhenCreatingPathDictionaryFromPackages( |
| self, mock_chroot_paths_to_symlinks, mock_get_chroot_paths): |
| |
| # Test function to simulate '_ConvertChrootPathsToSymLinkPaths' when a |
| # symlink does not start with the prefix '/mnt/host/source'. |
| def BadPrefixChrootPath(chroot_path, chroot_file_paths): |
| raise ValueError('Invalid prefix for the chroot path: ' |
| '/some/chroot/path/to/package-r1.ebuild') |
| |
| # Simulate 'GetChrootBuildPaths' when valid packages are passed in. |
| # |
| # Returns a list of chroot paths. |
| mock_get_chroot_paths.return_value = [ |
| '/some/chroot/path/to/package-r1.ebuild' |
| ] |
| |
| # Use test function to simulate '_ConvertChrootPathsToSymLinkPaths' |
| # 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_next_hash.CreatePathDictionaryFromPackages( |
| '/some/path/to/chroot', ['test-pckg/package']) |
| |
| self.assertEqual( |
| err.exception.message, 'Invalid prefix for the chroot path: ' |
| '/some/chroot/path/to/package-r1.ebuild') |
| |
| mock_get_chroot_paths.assert_called_once_with('/some/path/to/chroot', |
| ['test-pckg/package']) |
| |
| mock_chroot_paths_to_symlinks.assert_called_once_with( |
| '/some/path/to/chroot', ['/some/chroot/path/to/package-r1.ebuild']) |
| |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'GetChrootBuildPaths') |
| @mock.patch.object(update_chromeos_llvm_next_hash, |
| '_ConvertChrootPathsToSymLinkPaths') |
| @mock.patch.object(update_chromeos_llvm_next_hash, |
| 'GetEbuildPathsFromSymLinkPaths') |
| def testSuccessfullyCreatedPathDictionaryFromPackages( |
| self, mock_ebuild_paths_from_symlink_paths, mock_chroot_paths_to_symlinks, |
| mock_get_chroot_paths): |
| |
| # Simulate 'GetChrootBuildPaths' when returning a chroot path for a valid |
| # package. |
| # |
| # Returns a list of chroot paths. |
| mock_get_chroot_paths.return_value = [ |
| '/mnt/host/source/src/path/to/package-r1.ebuild' |
| ] |
| |
| # Simulate '_ConvertChrootPathsToSymLinkPaths' 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 = [ |
| '/some/path/to/chroot/src/path/to/package-r1.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 = { |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild': |
| '/some/path/to/chroot/src/path/to/package.ebuild' |
| } |
| |
| self.assertEqual( |
| update_chromeos_llvm_next_hash.CreatePathDictionaryFromPackages( |
| '/some/path/to/chroot', ['test-pckg/package']), { |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild': |
| '/some/path/to/chroot/src/path/to/package.ebuild' |
| }) |
| |
| mock_get_chroot_paths.assert_called_once_with('/some/path/to/chroot', |
| ['test-pckg/package']) |
| |
| mock_chroot_paths_to_symlinks.assert_called_once_with( |
| '/some/path/to/chroot', |
| ['/mnt/host/source/src/path/to/package-r1.ebuild']) |
| |
| mock_ebuild_paths_from_symlink_paths.assert_called_once_with( |
| ['/some/path/to/chroot/src/path/to/package-r1.ebuild']) |
| |
| @mock.patch.object(os.path, 'dirname') |
| @mock.patch.object(update_chromeos_llvm_next_hash, '_CreateRepo') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UpdateBuildLLVMNextHash') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UprevEbuild') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UploadChanges') |
| @mock.patch.object(update_chromeos_llvm_next_hash, '_DeleteRepo') |
| def testExceptionRaisedWhenUpdatingPackages( |
| self, mock_delete_repo, mock_upload_changes, mock_uprev_ebuild, |
| mock_update_llvm_next, mock_create_repo, mock_dirname): |
| |
| # Test function to simulate 'os.path.dirname' returning a path to the |
| # directory of an ebuild file. |
| @CallCountsToMockFunctions |
| def SuccessfullyGetDirectoryPath(call_count, ebuild_path): |
| # Returns the absolute path to the directory of the ebuild file. |
| # |
| # 'os.path.dirname()' is expected to be called 2 times. |
| if call_count == 0 or call_count == 1: |
| return '/some/path/to/chroot/src/path/to' |
| |
| # 'os.path.dirname()' was called more than 2 times. |
| assert False, 'os.path.dirname() was called more than 2 times.' |
| |
| # Test function to simulate '_CreateRepo' when successfully created the |
| # repo on a valid repo path. |
| def SuccessfullyCreateRepoForChanges(repo_path, llvm_hash): |
| self.assertEqual(llvm_hash, 'a123testhash4') |
| return |
| |
| # Test function to simulate 'UpdateBuildLLVMNextHash' when successfully |
| # updated the ebuild's 'LLVM_NEXT_HASH'. |
| def SuccessfullyUpdatedLLVMNextHash(ebuild_path, llvm_hash, llvm_version): |
| self.assertEqual(ebuild_path, |
| '/some/path/to/chroot/src/path/to/package.ebuild') |
| self.assertEqual(llvm_hash, 'a123testhash4') |
| self.assertEqual(llvm_version, 1000) |
| return |
| |
| # Test function to simulate 'UprevEbuild' when the symlink to the ebuild |
| # does not have a revision number. |
| def FailedToUprevEbuild(symlink_path): |
| # 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(repo_path, llvm_hash, commit_messages): |
| # Test function should not be called (i.e. execution should resume in the |
| # 'finally' block) because 'UprevEbuild()' raised an |
| # exception. |
| assert False, 'Failed to go to \'finally\' block ' \ |
| 'after the exception was raised.' |
| |
| # Use test function to simulate behavior. |
| mock_dirname.side_effect = SuccessfullyGetDirectoryPath |
| mock_create_repo.side_effect = SuccessfullyCreateRepoForChanges |
| mock_update_llvm_next.side_effect = SuccessfullyUpdatedLLVMNextHash |
| mock_uprev_ebuild.side_effect = FailedToUprevEbuild |
| mock_upload_changes.side_effect = ShouldNotExecuteUploadChanges |
| |
| # Verify exception is raised when an exception is thrown within |
| # the 'try' block by UprevEbuild function. |
| with self.assertRaises(ValueError) as err: |
| update_chromeos_llvm_next_hash.UpdatePackages({ |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild': |
| '/some/path/to/chroot/src/path/to/package.ebuild' |
| }, 'a123testhash4', 1000) |
| |
| self.assertEqual(err.exception.message, 'Failed to uprev the ebuild.') |
| |
| self.assertEqual(mock_dirname.call_count, 2) |
| |
| mock_create_repo.assert_called_once_with('/some/path/to/chroot/src/path/to', |
| 'a123testhash4') |
| |
| mock_update_llvm_next.assert_called_once_with( |
| '/some/path/to/chroot/src/path/to/package.ebuild', 'a123testhash4', |
| 1000) |
| |
| mock_uprev_ebuild.assert_called_once_with( |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild') |
| |
| mock_upload_changes.assert_not_called() |
| |
| mock_delete_repo.assert_called_once_with('/some/path/to/chroot/src/path/to', |
| 'a123testhash4') |
| |
| @mock.patch.object(os.path, 'dirname') |
| @mock.patch.object(update_chromeos_llvm_next_hash, '_CreateRepo') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UpdateBuildLLVMNextHash') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UprevEbuild') |
| @mock.patch.object(os.path, 'basename') |
| @mock.patch.object(update_chromeos_llvm_next_hash, 'UploadChanges') |
| @mock.patch.object(update_chromeos_llvm_next_hash, '_DeleteRepo') |
| def testSuccessfullyUpdatedPackages( |
| self, mock_delete_repo, mock_upload_changes, mock_basename, |
| mock_uprev_ebuild, mock_update_llvm_next, mock_create_repo, mock_dirname): |
| |
| # Test function to simulate 'os.path.dirname' on a valid ebuild path. |
| @CallCountsToMockFunctions |
| def SuccessfullyGetDirectoryPath(call_count, ebuild_path): |
| # Returns the absolute path to the directory of the ebuild file. |
| # |
| # 'os.path.dirname()' is expected to be called 3 times. |
| if call_count == 0 or call_count == 1: |
| return '/some/path/to/chroot/src/path/to' |
| if call_count == 2: |
| return '/some/path/to/chroot/src/path' |
| |
| # 'os.path.dirname()' was called more than 3 times. |
| assert False, 'os.path.dirname() was called more than 3 times.' |
| |
| # Test function to simulate '_CreateRepo' when successfully created the repo |
| # for the changes to be made to the ebuild files. |
| def SuccessfullyCreateRepoForChanges(repo_path, llvm_hash): |
| self.assertEqual(llvm_hash, 'a123testhash5') |
| return |
| |
| # Test function to simulate 'os.path.basename' when called on the ebuild |
| # path. |
| @CallCountsToMockFunctions |
| def SuccessfullyGetBaseNameOfDirectory(call_count, path_to_ebuild_dir): |
| if call_count == 0: |
| self.assertEqual(path_to_ebuild_dir, '/some/path/to/chroot/src/path/to') |
| |
| return 'to' |
| if call_count == 1: |
| self.assertEqual(path_to_ebuild_dir, '/some/path/to/chroot/src/path') |
| |
| return 'path' |
| |
| # Test function was called more times than expected (2 times). |
| assert False, 'os.path.basename() was called more than 2 times.' |
| |
| # Test function to simulate 'UploadChanges' after a successfull update of |
| # 'LLVM_NEXT_HASH" of the ebuild file. |
| def SuccessfullyUpdatedLLVMNextHash(ebuild_path, llvm_hash, llvm_version): |
| self.assertEqual(ebuild_path, |
| '/some/path/to/chroot/src/path/to/package.ebuild') |
| self.assertEqual(llvm_hash, 'a123testhash5') |
| self.assertEqual(llvm_version, 1000) |
| return |
| |
| # Test function to simulate 'UprevEbuild' when successfully incremented |
| # the revision number by 1. |
| def SuccessfullyUprevedEbuild(symlink_path): |
| self.assertEqual(symlink_path, |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild') |
| |
| return |
| |
| # Use test function to simulate behavior. |
| mock_dirname.side_effect = SuccessfullyGetDirectoryPath |
| mock_create_repo.side_effect = SuccessfullyCreateRepoForChanges |
| mock_update_llvm_next.side_effect = SuccessfullyUpdatedLLVMNextHash |
| mock_uprev_ebuild.side_effect = SuccessfullyUprevedEbuild |
| mock_basename.side_effect = SuccessfullyGetBaseNameOfDirectory |
| |
| update_chromeos_llvm_next_hash.UpdatePackages({ |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild': |
| '/some/path/to/chroot/src/path/to/package.ebuild' |
| }, 'a123testhash5', 1000) |
| |
| self.assertEqual(mock_dirname.call_count, 3) |
| |
| mock_create_repo.assert_called_once_with('/some/path/to/chroot/src/path/to', |
| 'a123testhash5') |
| |
| mock_update_llvm_next.assert_called_once_with( |
| '/some/path/to/chroot/src/path/to/package.ebuild', 'a123testhash5', |
| 1000) |
| |
| mock_uprev_ebuild.assert_called_once_with( |
| '/some/path/to/chroot/src/path/to/package-r1.ebuild') |
| |
| self.assertEqual(mock_basename.call_count, 2) |
| |
| expected_commit_messages = ' '.join([ |
| '-m %s' % quote('llvm-next: Update packages to r1000'), |
| '-m %s' % quote('Following packages have been updated:'), |
| '-m %s' % quote('path/to') |
| ]) |
| |
| mock_upload_changes.assert_called_once_with( |
| '/some/path/to/chroot/src/path/to', 'a123testhash5', |
| expected_commit_messages) |
| |
| mock_delete_repo.assert_called_once_with('/some/path/to/chroot/src/path/to', |
| 'a123testhash5') |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
