| # Copyright 2014 The Chromium 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 the fetch_builds module.""" |
| |
| import errno |
| import unittest |
| |
| # The third-party mock module is expected to be available in PYTHONPATH. |
| import mock |
| |
| import fetch_build |
| |
| |
| # The tests below test private functions (W0212). |
| # Some methods don't reference self because they use the mock module (R0201). |
| # pylint: disable=R0201,W0212 |
| class FetchBuildTest(unittest.TestCase): |
| |
| def setUp(self): |
| # Mocks of the os and bisect_utils modules are used in the methods below. |
| cloud_storage_patcher = mock.patch('fetch_build.cloud_storage') |
| self.mock_cloud_storage = cloud_storage_patcher.start() |
| self.addCleanup(cloud_storage_patcher.stop) |
| |
| @mock.patch('fetch_build.os.path.exists') |
| def test_FetchFromCloudStorage_FileFound(self, mock_os_path_exists): |
| self.mock_cloud_storage.Exists.return_value = True |
| mock_os_path_exists.return_value = True |
| local_path = fetch_build.FetchFromCloudStorage( |
| 'my_bucket', 'remote/foo.zip', 'local') |
| self.assertEqual('local/foo.zip', local_path) |
| self.mock_cloud_storage.Get.assert_called_with( |
| 'my_bucket', 'remote/foo.zip', 'local/foo.zip') |
| |
| def test_FetchFromCloudStorage_FileNotFound(self): |
| self.mock_cloud_storage.Exists.return_value = False |
| local_path = fetch_build.FetchFromCloudStorage( |
| 'my_bucket', 'remote/foo.zip', 'local') |
| self.assertIsNone(local_path) |
| self.assertFalse(self.mock_cloud_storage.Get.called) |
| |
| |
| class BuildArchiveTest(unittest.TestCase): |
| |
| def test_CreatePerfBuildArchive(self): |
| archive = fetch_build.BuildArchive.Create(fetch_build.PERF_BUILDER) |
| self.assertEqual('chrome-perf', archive.BucketName()) |
| self.assertTrue(isinstance(archive, fetch_build.PerfBuildArchive)) |
| |
| def test_CreateFullBuildArchive(self): |
| archive = fetch_build.BuildArchive.Create(fetch_build.FULL_BUILDER) |
| archive._platform = 'linux' |
| self.assertEqual('chromium-linux-archive', archive.BucketName()) |
| self.assertTrue(isinstance(archive, fetch_build.FullBuildArchive)) |
| |
| def test_BuildArchive_NonExistentType(self): |
| self.assertRaises( |
| NotImplementedError, fetch_build.BuildArchive.Create, 'other') |
| |
| def test_FullBuildArchive_Linux(self): |
| archive = fetch_build.FullBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual('chromium-linux-archive', archive.BucketName()) |
| self.assertEqual( |
| 'chromium.linux/Linux Builder/full-build-linux_1234567890abcdef.zip', |
| archive.FilePath('1234567890abcdef')) |
| |
| def test_FullBuildArchive_Android(self): |
| archive = fetch_build.FullBuildArchive() |
| archive._platform = 'android' |
| self.assertEqual('chromium-android', archive.BucketName()) |
| self.assertEqual( |
| 'android_main_rel/full-build-linux_1234567890abcdef.zip', |
| archive.FilePath('1234567890abcdef')) |
| |
| def test_FullBuildArchive_Linux_BuilderName(self): |
| archive = fetch_build.FullBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual('linux_full_bisect_builder', archive.GetBuilderName()) |
| |
| def test_FullBuildArchive_Windows_BuildTime(self): |
| archive = fetch_build.FullBuildArchive() |
| archive._platform = 'win' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_PerfBuildArchive_Linux(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual('chrome-perf', archive.BucketName()) |
| self.assertEqual( |
| 'Linux Builder/full-build-linux_1234567890abcdef.zip', |
| archive.FilePath('1234567890abcdef')) |
| |
| def test_PerfBuildArchive_Android(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'android' |
| self.assertEqual('chrome-perf', archive.BucketName()) |
| self.assertEqual( |
| 'android_perf_rel/full-build-linux_123456.zip', |
| archive.FilePath('123456')) |
| |
| def test_PerfBuildArchive_AndroidArm64(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'android_arm64' |
| self.assertEqual('chrome-perf', archive.BucketName()) |
| self.assertEqual( |
| 'android_perf_rel_arm64/full-build-linux_123456.zip', |
| archive.FilePath('123456')) |
| |
| def test_PerfBuildArchive_64BitWindows(self): |
| archive = fetch_build.PerfBuildArchive(target_arch='x64') |
| archive._platform = 'win64' |
| self.assertEqual('chrome-perf', archive.BucketName()) |
| self.assertEqual( |
| 'Win x64 Builder/full-build-win32_123456.zip', |
| archive.FilePath('123456')) |
| |
| def test_PerfBuildArchive_WithDepsPatchSha(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual( |
| 'Linux Builder/full-build-linux_123456' |
| '_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.zip', |
| archive.FilePath(123456, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')) |
| |
| def test_PerfBuildArchive_64BitWindows_BuilderName(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'win64' |
| self.assertEqual('winx64_bisect_builder', archive.GetBuilderName()) |
| |
| def test_PerfBuildArchive_64BitWindows_BuildTime(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'win64' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_PerfBuildArchive_Windows_BuilderName(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'win' |
| self.assertEqual('win_perf_bisect_builder', archive.GetBuilderName()) |
| |
| def test_PerfBuildArchive_Windows_BuildTime(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'win' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_PerfBuildArchive_Linux_BuilderName(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual('linux_perf_bisect_builder', archive.GetBuilderName()) |
| |
| def test_PerfBuildArchive_Linux_BuildTime(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'linux' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_PerfBuildArchive_Android_BuilderName(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'android' |
| self.assertEqual('android_perf_bisect_builder', archive.GetBuilderName()) |
| |
| def test_PerfBuildArchive_Android_BuildTime(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'android' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_PerfBuildArchive_Mac_BuilderName(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'mac' |
| self.assertEqual('mac_perf_bisect_builder', archive.GetBuilderName()) |
| |
| def test_PerfBuildArchive_mac_BuildTime(self): |
| archive = fetch_build.PerfBuildArchive() |
| archive._platform = 'mac' |
| self.assertEqual(14400, archive.GetBuilderBuildTime()) |
| |
| def test_GetBuildBotUrl_Perf(self): |
| self.assertEqual( |
| fetch_build.PERF_TRY_SERVER_URL, |
| fetch_build.GetBuildBotUrl(fetch_build.PERF_BUILDER)) |
| |
| def test_GetBuildBotUrl_full(self): |
| self.assertEqual( |
| fetch_build.LINUX_TRY_SERVER_URL, |
| fetch_build.GetBuildBotUrl(fetch_build.FULL_BUILDER)) |
| |
| |
| class UnzipTest(unittest.TestCase): |
| |
| def setUp(self): |
| # Mocks of the os and bisect_utils modules are used in the methods below. |
| os_patcher = mock.patch('fetch_build.os') |
| self.mock_os = os_patcher.start() |
| self.addCleanup(os_patcher.stop) |
| |
| bisect_utils_patcher = mock.patch('fetch_build.bisect_utils') |
| self.mock_bisect_utils = bisect_utils_patcher.start() |
| self.addCleanup(bisect_utils_patcher.stop) |
| |
| @mock.patch('fetch_build._MakeDirectory') |
| @mock.patch('fetch_build._UnzipUsingCommand') |
| def test_Unzip_Linux(self, mock_UnzipUsingCommand, mock_MakeDirectory): |
| self.mock_bisect_utils.IsLinuxHost.return_value = True |
| self.mock_bisect_utils.IsMacHost.return_value = False |
| self.mock_bisect_utils.IsWindowsHost.return_value = False |
| fetch_build.Unzip('x.zip', 'out_dir', verbose=False) |
| mock_MakeDirectory.assert_called_with('out_dir') |
| mock_UnzipUsingCommand.assert_called_with( |
| ['unzip', '-o'], 'x.zip', 'out_dir') |
| |
| @mock.patch('fetch_build._MakeDirectory') |
| @mock.patch('fetch_build._UnzipUsingZipFile') |
| def test_Unzip_Mac_LargeFile( |
| self, mock_UnzipUsingZipFile, mock_MakeDirectory): |
| # The zipfile module is used to unzip on mac when the file is > 4GB. |
| self.mock_bisect_utils.IsLinuxHost.return_value = False |
| self.mock_bisect_utils.IsMacHost.return_value = True |
| self.mock_bisect_utils.IsWindowsHost.return_value = False |
| self.mock_os.path.getsize.return_value = 2 ** 33 # 8GB |
| fetch_build.Unzip('x.zip', 'out_dir', verbose=False) |
| mock_MakeDirectory.assert_called_with('out_dir') |
| mock_UnzipUsingZipFile.assert_called_with('x.zip', 'out_dir', False) |
| |
| def test_UnzipUsingCommand(self): |
| # The _UnzipUsingCommand function should move to the output |
| # directory and run the command with the file's absolute path. |
| self.mock_os.path.abspath.return_value = '/foo/some/path/x.zip' |
| self.mock_os.getcwd.return_value = 'curr_dir' |
| self.mock_bisect_utils.RunProcess.return_value = 0 |
| fetch_build._UnzipUsingCommand(['unzip'], 'x.zip', 'out_dir') |
| self.mock_os.chdir.assert_has_calls( |
| [mock.call('out_dir'), mock.call('curr_dir')]) |
| self.mock_bisect_utils.RunProcess.assert_called_with( |
| ['unzip', '/foo/some/path/x.zip']) |
| |
| def test_MakeDirectory(self): |
| # _MakeDirectory uses os.makedirs. |
| fetch_build._MakeDirectory('some/path') |
| self.mock_os.makedirs.assert_called_with('some/path') |
| |
| def test_MakeDirectory_RaisesError(self): |
| self.mock_os.makedirs.side_effect = OSError() |
| self.assertRaises(OSError, fetch_build._MakeDirectory, 'some/path') |
| |
| def test_MakeDirectory_NoErrorIfDirectoryAlreadyExists(self): |
| already_exists = OSError() |
| already_exists.errno = errno.EEXIST |
| self.mock_os.makedirs.side_effect = already_exists |
| fetch_build._MakeDirectory('some/path') |
| |
| @mock.patch('fetch_build.shutil') |
| def test_RemoveDirectoryTree(self, mock_shutil): |
| # _RemoveDirectoryTree uses shutil.rmtree. |
| fetch_build._RemoveDirectoryTree('some/path') |
| mock_shutil.rmtree.assert_called_with('some/path') |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
| |
