| #!/usr/bin/env python3 |
| # Copyright 2020 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tests for rust_uprev.py""" |
| |
| import os |
| from pathlib import Path |
| import shutil |
| import subprocess |
| import tempfile |
| import unittest |
| from unittest import mock |
| |
| from llvm_tools import git |
| |
| |
| # rust_uprev sets SOURCE_ROOT to the output of `repo --show-toplevel`. |
| # The mock below makes us not actually run repo but use a fake value |
| # instead. |
| with mock.patch("subprocess.check_output", return_value="/fake/chromiumos"): |
| import rust_uprev |
| |
| |
| def _fail_command(cmd, *_args, **_kwargs): |
| err = subprocess.CalledProcessError(returncode=1, cmd=cmd) |
| err.stderr = b"mock failure" |
| raise err |
| |
| |
| def start_mock(obj, *args, **kwargs): |
| """Creates a patcher, starts it, and registers a cleanup to stop it. |
| |
| Args: |
| obj: |
| the object to attach the cleanup to |
| *args: |
| passed to mock.patch() |
| **kwargs: |
| passsed to mock.patch() |
| """ |
| patcher = mock.patch(*args, **kwargs) |
| val = patcher.start() |
| obj.addCleanup(patcher.stop) |
| return val |
| |
| |
| class FetchDistfileTest(unittest.TestCase): |
| """Tests rust_uprev.fetch_distfile_from_mirror()""" |
| |
| @mock.patch.object( |
| rust_uprev, "get_distdir", return_value=Path("/fake/distfiles") |
| ) |
| @mock.patch.object(subprocess, "call", side_effect=_fail_command) |
| def test_fetch_difstfile_fail(self, *_args) -> None: |
| with self.assertRaises(subprocess.CalledProcessError): |
| rust_uprev.fetch_distfile_from_mirror("test_distfile.tar.gz") |
| |
| @mock.patch.object( |
| rust_uprev, |
| "get_command_output_unchecked", |
| return_value="AccessDeniedException: Access denied.", |
| ) |
| @mock.patch.object( |
| rust_uprev, "get_distdir", return_value=Path("/fake/distfiles") |
| ) |
| @mock.patch.object(subprocess, "call", return_value=0) |
| def test_fetch_distfile_acl_access_denied(self, *_args) -> None: |
| rust_uprev.fetch_distfile_from_mirror("test_distfile.tar.gz") |
| |
| @mock.patch.object( |
| rust_uprev, |
| "get_command_output_unchecked", |
| return_value='[ { "entity": "allUsers", "role": "READER" } ]', |
| ) |
| @mock.patch.object( |
| rust_uprev, "get_distdir", return_value=Path("/fake/distfiles") |
| ) |
| @mock.patch.object(subprocess, "call", return_value=0) |
| def test_fetch_distfile_acl_ok(self, *_args) -> None: |
| rust_uprev.fetch_distfile_from_mirror("test_distfile.tar.gz") |
| |
| @mock.patch.object( |
| rust_uprev, |
| "get_command_output_unchecked", |
| return_value='[ { "entity": "___fake@google.com", "role": "OWNER" } ]', |
| ) |
| @mock.patch.object( |
| rust_uprev, "get_distdir", return_value=Path("/fake/distfiles") |
| ) |
| @mock.patch.object(subprocess, "call", return_value=0) |
| def test_fetch_distfile_acl_wrong(self, *_args) -> None: |
| with self.assertRaisesRegex(Exception, "allUsers.*READER"): |
| with self.assertLogs(level="ERROR") as log: |
| rust_uprev.fetch_distfile_from_mirror("test_distfile.tar.gz") |
| self.assertIn( |
| '[ { "entity": "___fake@google.com", "role": "OWNER" } ]', |
| "\n".join(log.output), |
| ) |
| |
| |
| class FetchRustSrcFromUpstreamTest(unittest.TestCase): |
| """Tests for rust_uprev.fetch_rust_src_from_upstream.""" |
| |
| def setUp(self) -> None: |
| self._mock_get_distdir = start_mock( |
| self, |
| "rust_uprev.get_distdir", |
| return_value=Path("/fake/distfiles"), |
| ) |
| |
| self._mock_gpg = start_mock( |
| self, |
| "subprocess.run", |
| side_effect=self.fake_gpg, |
| ) |
| |
| self._mock_urlretrieve = start_mock( |
| self, |
| "urllib.request.urlretrieve", |
| side_effect=self.fake_urlretrieve, |
| ) |
| |
| self._mock_rust_signing_key = start_mock( |
| self, |
| "rust_uprev.RUST_SIGNING_KEY", |
| "1234567", |
| ) |
| |
| @staticmethod |
| def fake_urlretrieve(src: str, dest: Path) -> None: |
| pass |
| |
| @staticmethod |
| def fake_gpg(cmd, **_kwargs): |
| val = mock.Mock() |
| val.returncode = 0 |
| val.stdout = "" |
| if "--verify" in cmd: |
| val.stdout = "GOODSIG 1234567" |
| return val |
| |
| def test_success(self): |
| with mock.patch("rust_uprev.GPG", "gnupg"): |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self._mock_urlretrieve.has_calls( |
| [ |
| ( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ), |
| ( |
| "fakehttps://rustc-1.60.3-src.tar.gz.asc", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz.asc"), |
| ), |
| ] |
| ) |
| self._mock_gpg.has_calls( |
| [ |
| (["gnupg", "--refresh-keys", "1234567"], {"check": True}), |
| ] |
| ) |
| |
| def test_no_signature_file(self): |
| def _urlretrieve(src, dest): |
| if src.endswith(".asc"): |
| raise Exception("404 not found") |
| return self.fake_urlretrieve(src, dest) |
| |
| self._mock_urlretrieve.side_effect = _urlretrieve |
| |
| with self.assertRaises(rust_uprev.SignatureVerificationError) as ctx: |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self.assertIn("error fetching signature file", ctx.exception.message) |
| |
| def test_key_expired(self): |
| def _gpg_verify(cmd, *args, **kwargs): |
| val = self.fake_gpg(cmd, *args, **kwargs) |
| if "--verify" in cmd: |
| val.stdout = "EXPKEYSIG 1234567" |
| return val |
| |
| self._mock_gpg.side_effect = _gpg_verify |
| |
| with self.assertRaises(rust_uprev.SignatureVerificationError) as ctx: |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self.assertIn("key has expired", ctx.exception.message) |
| |
| def test_key_revoked(self): |
| def _gpg_verify(cmd, *args, **kwargs): |
| val = self.fake_gpg(cmd, *args, **kwargs) |
| if "--verify" in cmd: |
| val.stdout = "REVKEYSIG 1234567" |
| return val |
| |
| self._mock_gpg.side_effect = _gpg_verify |
| |
| with self.assertRaises(rust_uprev.SignatureVerificationError) as ctx: |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self.assertIn("key has been revoked", ctx.exception.message) |
| |
| def test_signature_expired(self): |
| def _gpg_verify(cmd, *args, **kwargs): |
| val = self.fake_gpg(cmd, *args, **kwargs) |
| if "--verify" in cmd: |
| val.stdout = "EXPSIG 1234567" |
| return val |
| |
| self._mock_gpg.side_effect = _gpg_verify |
| |
| with self.assertRaises(rust_uprev.SignatureVerificationError) as ctx: |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self.assertIn("signature has expired", ctx.exception.message) |
| |
| def test_wrong_key(self): |
| def _gpg_verify(cmd, *args, **kwargs): |
| val = self.fake_gpg(cmd, *args, **kwargs) |
| if "--verify" in cmd: |
| val.stdout = "GOODSIG 0000000" |
| return val |
| |
| self._mock_gpg.side_effect = _gpg_verify |
| |
| with self.assertRaises(rust_uprev.SignatureVerificationError) as ctx: |
| rust_uprev.fetch_rust_src_from_upstream( |
| "fakehttps://rustc-1.60.3-src.tar.gz", |
| Path("/fake/distfiles/rustc-1.60.3-src.tar.gz"), |
| ) |
| self.assertIn("1234567 not found", ctx.exception.message) |
| |
| |
| class FindEbuildPathTest(unittest.TestCase): |
| """Tests for rust_uprev.find_ebuild_path()""" |
| |
| def test_exact_version(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| ebuild = tmpdir / "test-1.3.4.ebuild" |
| ebuild.touch() |
| (tmpdir / "test-1.2.3.ebuild").touch() |
| result = rust_uprev.find_ebuild_path( |
| tmpdir, "test", rust_uprev.RustVersion(1, 3, 4) |
| ) |
| self.assertEqual(result, ebuild) |
| |
| def test_no_version(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| ebuild = tmpdir / "test-1.2.3.ebuild" |
| ebuild.touch() |
| result = rust_uprev.find_ebuild_path(tmpdir, "test") |
| self.assertEqual(result, ebuild) |
| |
| def test_patch_version(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| ebuild = tmpdir / "test-1.3.4-r3.ebuild" |
| ebuild.touch() |
| (tmpdir / "test-1.2.3.ebuild").touch() |
| result = rust_uprev.find_ebuild_path( |
| tmpdir, "test", rust_uprev.RustVersion(1, 3, 4) |
| ) |
| self.assertEqual(result, ebuild) |
| |
| def test_multiple_versions(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| (tmpdir / "test-1.3.4-r3.ebuild").touch() |
| (tmpdir / "test-1.3.5.ebuild").touch() |
| with self.assertRaises(AssertionError): |
| rust_uprev.find_ebuild_path(tmpdir, "test") |
| |
| def test_selected_version(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| ebuild = tmpdir / "test-1.3.4-r3.ebuild" |
| ebuild.touch() |
| (tmpdir / "test-1.3.5.ebuild").touch() |
| result = rust_uprev.find_ebuild_path( |
| tmpdir, "test", rust_uprev.RustVersion(1, 3, 4) |
| ) |
| self.assertEqual(result, ebuild) |
| |
| def test_symlink(self): |
| # Symlinks to ebuilds in the same directory are allowed, and the return |
| # value is the regular file. |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| ebuild = tmpdir / "test-1.3.4.ebuild" |
| ebuild.touch() |
| (tmpdir / "test-1.3.4-r1.ebuild").symlink_to("test-1.3.4.ebuild") |
| result = rust_uprev.find_ebuild_path(tmpdir, "test") |
| self.assertEqual(result, ebuild) |
| |
| |
| class FindRustVersionsTest(unittest.TestCase): |
| """Tests for rust_uprev.find_rust_versions.""" |
| |
| def test_with_symlinks(self): |
| with tempfile.TemporaryDirectory() as t: |
| tmpdir = Path(t) |
| rust_1_49_1_ebuild = tmpdir / "rust-1.49.1.ebuild" |
| rust_1_50_0_ebuild = tmpdir / "rust-1.50.0.ebuild" |
| rust_1_50_0_r1_ebuild = tmpdir / "rust-1.50.0-r1.ebuild" |
| rust_1_49_1_ebuild.touch() |
| rust_1_50_0_ebuild.touch() |
| rust_1_50_0_r1_ebuild.symlink_to(rust_1_50_0_ebuild) |
| with mock.patch("rust_uprev.RUST_PATH", tmpdir): |
| actual = rust_uprev.find_rust_versions() |
| expected = [ |
| (rust_uprev.RustVersion(1, 49, 1), rust_1_49_1_ebuild), |
| (rust_uprev.RustVersion(1, 50, 0), rust_1_50_0_ebuild), |
| ] |
| self.assertEqual(actual, expected) |
| |
| |
| class MirrorHasFileTest(unittest.TestCase): |
| """Tests for rust_uprev.mirror_has_file.""" |
| |
| @mock.patch.object(subprocess, "run") |
| def test_no(self, mock_run): |
| mock_run.return_value = mock.Mock( |
| returncode=1, |
| stdout="CommandException: One or more URLs matched no objects.", |
| ) |
| self.assertFalse(rust_uprev.mirror_has_file("rustc-1.69.0-src.tar.gz")) |
| |
| @mock.patch.object(subprocess, "run") |
| def test_yes(self, mock_run): |
| mock_run.return_value = mock.Mock( |
| returncode=0, |
| # pylint: disable=line-too-long |
| stdout="gs://chromeos-localmirror/distfiles/rustc-1.69.0-src.tar.gz", |
| ) |
| self.assertTrue(rust_uprev.mirror_has_file("rustc-1.69.0-src.tar.gz")) |
| |
| |
| class MirrorRustSourceTest(unittest.TestCase): |
| """Tests for rust_uprev.mirror_rust_source.""" |
| |
| def setUp(self) -> None: |
| start_mock(self, "rust_uprev.GSUTIL", "gsutil") |
| start_mock(self, "rust_uprev.MIRROR_PATH", "fakegs://fakemirror/") |
| start_mock( |
| self, "rust_uprev.get_distdir", return_value=Path("/fake/distfiles") |
| ) |
| self.mock_mirror_has_file = start_mock( |
| self, |
| "rust_uprev.mirror_has_file", |
| ) |
| self.mock_fetch_rust_src_from_upstream = start_mock( |
| self, |
| "rust_uprev.fetch_rust_src_from_upstream", |
| ) |
| self.mock_subprocess_run = start_mock( |
| self, |
| "subprocess.run", |
| ) |
| |
| def test_already_present(self): |
| self.mock_mirror_has_file.return_value = True |
| rust_uprev.mirror_rust_source( |
| rust_uprev.RustVersion.parse("1.67.3"), |
| ) |
| self.mock_fetch_rust_src_from_upstream.assert_not_called() |
| self.mock_subprocess_run.assert_not_called() |
| |
| def test_fetch_and_upload(self): |
| self.mock_mirror_has_file.return_value = False |
| rust_uprev.mirror_rust_source( |
| rust_uprev.RustVersion.parse("1.67.3"), |
| ) |
| self.mock_fetch_rust_src_from_upstream.called_once() |
| self.mock_subprocess_run.has_calls( |
| [ |
| ( |
| [ |
| "gsutil", |
| "cp", |
| "-a", |
| "public-read", |
| "/fake/distdir/rustc-1.67.3-src.tar.gz", |
| "fakegs://fakemirror/rustc-1.67.3-src.tar.gz", |
| ] |
| ), |
| ] |
| ) |
| |
| |
| class RemoveEbuildVersionTest(unittest.TestCase): |
| """Tests for rust_uprev.remove_ebuild_version()""" |
| |
| @mock.patch.object(subprocess, "check_call") |
| def test_single(self, check_call): |
| with tempfile.TemporaryDirectory() as tmpdir: |
| ebuild_dir = Path(tmpdir, "test-ebuilds") |
| ebuild_dir.mkdir() |
| ebuild = Path(ebuild_dir, "test-3.1.4.ebuild") |
| ebuild.touch() |
| Path(ebuild_dir, "unrelated-1.0.0.ebuild").touch() |
| rust_uprev.remove_ebuild_version( |
| ebuild_dir, "test", rust_uprev.RustVersion(3, 1, 4) |
| ) |
| check_call.assert_called_once_with( |
| ["git", "rm", "test-3.1.4.ebuild"], cwd=ebuild_dir |
| ) |
| |
| @mock.patch.object(subprocess, "check_call") |
| def test_symlink(self, check_call): |
| with tempfile.TemporaryDirectory() as tmpdir: |
| ebuild_dir = Path(tmpdir, "test-ebuilds") |
| ebuild_dir.mkdir() |
| ebuild = Path(ebuild_dir, "test-3.1.4.ebuild") |
| ebuild.touch() |
| symlink = Path(ebuild_dir, "test-3.1.4-r5.ebuild") |
| symlink.symlink_to(ebuild.name) |
| Path(ebuild_dir, "unrelated-1.0.0.ebuild").touch() |
| rust_uprev.remove_ebuild_version( |
| ebuild_dir, "test", rust_uprev.RustVersion(3, 1, 4) |
| ) |
| check_call.assert_has_calls( |
| [ |
| mock.call( |
| ["git", "rm", "test-3.1.4.ebuild"], cwd=ebuild_dir |
| ), |
| mock.call( |
| ["git", "rm", "test-3.1.4-r5.ebuild"], cwd=ebuild_dir |
| ), |
| ], |
| any_order=True, |
| ) |
| |
| |
| class RustVersionTest(unittest.TestCase): |
| """Tests for RustVersion class""" |
| |
| def test_str(self): |
| obj = rust_uprev.RustVersion(major=1, minor=2, patch=3) |
| self.assertEqual(str(obj), "1.2.3") |
| |
| def test_parse_version_only(self): |
| expected = rust_uprev.RustVersion(major=1, minor=2, patch=3) |
| actual = rust_uprev.RustVersion.parse("1.2.3") |
| self.assertEqual(expected, actual) |
| |
| def test_parse_ebuild_name(self): |
| expected = rust_uprev.RustVersion(major=1, minor=2, patch=3) |
| actual = rust_uprev.RustVersion.parse_from_ebuild("rust-1.2.3.ebuild") |
| self.assertEqual(expected, actual) |
| |
| actual = rust_uprev.RustVersion.parse_from_ebuild( |
| "rust-1.2.3-r1.ebuild" |
| ) |
| self.assertEqual(expected, actual) |
| |
| def test_parse_fail(self): |
| with self.assertRaises(AssertionError) as context: |
| rust_uprev.RustVersion.parse("invalid-rust-1.2.3") |
| self.assertEqual( |
| "failed to parse 'invalid-rust-1.2.3'", str(context.exception) |
| ) |
| |
| |
| class PrepareUprevTest(unittest.TestCase): |
| """Tests for prepare_uprev step in rust_uprev""" |
| |
| def setUp(self): |
| self.version_old = rust_uprev.RustVersion(1, 2, 3) |
| self.version_new = rust_uprev.RustVersion(1, 3, 5) |
| |
| @mock.patch.object( |
| rust_uprev, |
| "find_ebuild_for_rust_version", |
| return_value=Path("/path/to/ebuild"), |
| ) |
| @mock.patch.object(rust_uprev, "get_command_output") |
| def test_success_with_template(self, mock_command, _ebuild_for_version): |
| expected = rust_uprev.PreparedUprev(self.version_old) |
| actual = rust_uprev.prepare_uprev( |
| rust_version=self.version_new, template=self.version_old |
| ) |
| self.assertEqual(expected, actual) |
| mock_command.assert_not_called() |
| |
| @mock.patch.object( |
| rust_uprev, |
| "find_ebuild_for_rust_version", |
| return_value="/path/to/ebuild", |
| ) |
| @mock.patch.object(rust_uprev, "get_command_output") |
| def test_return_none_with_template_larger_than_input( |
| self, mock_command, *_args |
| ): |
| ret = rust_uprev.prepare_uprev( |
| rust_version=self.version_old, template=self.version_new |
| ) |
| self.assertIsNone(ret) |
| mock_command.assert_not_called() |
| |
| def test_prepare_uprev_from_json(self): |
| json_result = (list(self.version_new),) |
| expected = rust_uprev.PreparedUprev( |
| self.version_new, |
| ) |
| actual = rust_uprev.prepare_uprev_from_json(json_result) |
| self.assertEqual(expected, actual) |
| |
| |
| class ToggleProfileData(unittest.TestCase): |
| """Tests functionality to include or exclude profile data from SRC_URI.""" |
| |
| ebuild_with_profdata = """ |
| # Some text here. |
| INCLUDE_PROFDATA_IN_SRC_URI=yes |
| some code here |
| """ |
| |
| ebuild_without_profdata = """ |
| # Some text here. |
| INCLUDE_PROFDATA_IN_SRC_URI= |
| some code here |
| """ |
| |
| ebuild_unexpected_content = """ |
| # Does not contain OMIT_PROFDATA_FROM_SRC_URI assignment |
| """ |
| |
| def setUp(self): |
| self.mock_read_text = start_mock(self, "pathlib.Path.read_text") |
| |
| def test_turn_off_profdata(self): |
| # Test that a file with profdata on is rewritten to a file with |
| # profdata off. |
| self.mock_read_text.return_value = self.ebuild_with_profdata |
| ebuild_file = "/path/to/eclass/cros-rustc.eclass" |
| with mock.patch("pathlib.Path.write_text") as mock_write_text: |
| rust_uprev.set_include_profdata_src(ebuild_file, include=False) |
| mock_write_text.assert_called_once_with( |
| self.ebuild_without_profdata, encoding="utf-8" |
| ) |
| |
| def test_turn_on_profdata(self): |
| # Test that a file with profdata off is rewritten to a file with |
| # profdata on. |
| self.mock_read_text.return_value = self.ebuild_without_profdata |
| ebuild_file = "/path/to/eclass/cros-rustc.eclass" |
| with mock.patch("pathlib.Path.write_text") as mock_write_text: |
| rust_uprev.set_include_profdata_src(ebuild_file, include=True) |
| mock_write_text.assert_called_once_with( |
| self.ebuild_with_profdata, encoding="utf-8" |
| ) |
| |
| def test_turn_on_profdata_fails_if_no_assignment(self): |
| # Test that if the string the code expects to find is not found, |
| # this causes an exception and the file is not overwritten. |
| self.mock_read_text.return_value = self.ebuild_unexpected_content |
| ebuild_file = "/path/to/eclass/cros-rustc.eclass" |
| with mock.patch("pathlib.Path.write_text") as mock_write_text: |
| with self.assertRaises(Exception): |
| rust_uprev.set_include_profdata_src(ebuild_file, include=False) |
| mock_write_text.assert_not_called() |
| |
| |
| class UpdateBootstrapVersionTest(unittest.TestCase): |
| """Tests for update_bootstrap_version step in rust_uprev""" |
| |
| ebuild_file_before = """ |
| BOOTSTRAP_VERSION="1.2.0" |
| """ |
| ebuild_file_after = """ |
| BOOTSTRAP_VERSION="1.3.6" |
| """ |
| |
| def setUp(self): |
| self.mock_read_text = start_mock(self, "pathlib.Path.read_text") |
| |
| def test_success(self): |
| self.mock_read_text.return_value = self.ebuild_file_before |
| # ebuild_file and new bootstrap version are deliberately different |
| ebuild_file = "/path/to/rust/cros-rustc.eclass" |
| with mock.patch("pathlib.Path.write_text") as mock_write_text: |
| rust_uprev.update_bootstrap_version( |
| ebuild_file, rust_uprev.RustVersion.parse("1.3.6") |
| ) |
| mock_write_text.assert_called_once_with( |
| self.ebuild_file_after, encoding="utf-8" |
| ) |
| |
| def test_fail_when_ebuild_misses_a_variable(self): |
| self.mock_read_text.return_value = "" |
| ebuild_file = "/path/to/rust/rust-1.3.5.ebuild" |
| with self.assertRaises(RuntimeError) as context: |
| rust_uprev.update_bootstrap_version( |
| ebuild_file, rust_uprev.RustVersion.parse("1.2.0") |
| ) |
| self.assertEqual( |
| "BOOTSTRAP_VERSION not found in /path/to/rust/rust-1.3.5.ebuild", |
| str(context.exception), |
| ) |
| |
| |
| class UpdateRustPackagesTests(unittest.TestCase): |
| """Tests for update_rust_packages step.""" |
| |
| def setUp(self): |
| self.old_version = rust_uprev.RustVersion(1, 1, 0) |
| self.current_version = rust_uprev.RustVersion(1, 2, 3) |
| self.new_version = rust_uprev.RustVersion(1, 3, 5) |
| self.ebuild_file = os.path.join( |
| rust_uprev.RUST_PATH, "rust-{self.new_version}.ebuild" |
| ) |
| |
| def test_add_new_rust_packages(self): |
| package_before = ( |
| f"dev-lang/rust-{self.old_version}\n" |
| f"dev-lang/rust-{self.current_version}" |
| ) |
| package_after = ( |
| f"dev-lang/rust-{self.old_version}\n" |
| f"dev-lang/rust-{self.current_version}\n" |
| f"dev-lang/rust-{self.new_version}" |
| ) |
| mock_open = mock.mock_open(read_data=package_before) |
| with mock.patch("builtins.open", mock_open): |
| rust_uprev.update_rust_packages( |
| "dev-lang/rust", self.new_version, add=True |
| ) |
| mock_open.return_value.__enter__().write.assert_called_once_with( |
| package_after |
| ) |
| |
| def test_remove_old_rust_packages(self): |
| package_before = ( |
| f"dev-lang/rust-{self.old_version}\n" |
| f"dev-lang/rust-{self.current_version}\n" |
| f"dev-lang/rust-{self.new_version}" |
| ) |
| package_after = ( |
| f"dev-lang/rust-{self.current_version}\n" |
| f"dev-lang/rust-{self.new_version}" |
| ) |
| mock_open = mock.mock_open(read_data=package_before) |
| with mock.patch("builtins.open", mock_open): |
| rust_uprev.update_rust_packages( |
| "dev-lang/rust", self.old_version, add=False |
| ) |
| mock_open.return_value.__enter__().write.assert_called_once_with( |
| package_after |
| ) |
| |
| |
| class RustUprevOtherStagesTests(unittest.TestCase): |
| """Tests for other steps in rust_uprev""" |
| |
| def setUp(self): |
| self.old_version = rust_uprev.RustVersion(1, 1, 0) |
| self.current_version = rust_uprev.RustVersion(1, 2, 3) |
| self.new_version = rust_uprev.RustVersion(1, 3, 5) |
| self.ebuild_file = os.path.join( |
| rust_uprev.RUST_PATH, "rust-{self.new_version}.ebuild" |
| ) |
| |
| @mock.patch.object(shutil, "copyfile") |
| @mock.patch.object(subprocess, "check_call") |
| def test_create_rust_ebuild(self, mock_call, mock_copy): |
| template_ebuild = ( |
| rust_uprev.EBUILD_PREFIX |
| / f"dev-lang/rust/rust-{self.current_version}.ebuild" |
| ) |
| new_ebuild = ( |
| rust_uprev.EBUILD_PREFIX |
| / f"dev-lang/rust/rust-{self.new_version}.ebuild" |
| ) |
| rust_uprev.create_ebuild( |
| "dev-lang", "rust", self.current_version, self.new_version |
| ) |
| mock_copy.assert_called_once_with( |
| template_ebuild, |
| new_ebuild, |
| ) |
| mock_call.assert_called_once_with( |
| ["git", "add", f"rust-{self.new_version}.ebuild"], |
| cwd=new_ebuild.parent, |
| ) |
| |
| @mock.patch.object(shutil, "copyfile") |
| @mock.patch.object(subprocess, "check_call") |
| def test_create_rust_host_ebuild(self, mock_call, mock_copy): |
| template_ebuild = ( |
| rust_uprev.EBUILD_PREFIX |
| / f"dev-lang/rust-host/rust-host-{self.current_version}.ebuild" |
| ) |
| new_ebuild = ( |
| rust_uprev.EBUILD_PREFIX |
| / f"dev-lang/rust-host/rust-host-{self.new_version}.ebuild" |
| ) |
| rust_uprev.create_ebuild( |
| "dev-lang", "rust-host", self.current_version, self.new_version |
| ) |
| mock_copy.assert_called_once_with( |
| template_ebuild, |
| new_ebuild, |
| ) |
| mock_call.assert_called_once_with( |
| ["git", "add", f"rust-host-{self.new_version}.ebuild"], |
| cwd=new_ebuild.parent, |
| ) |
| |
| @mock.patch.object(subprocess, "check_call") |
| def test_remove_virtual_rust(self, mock_call): |
| with tempfile.TemporaryDirectory() as tmpdir: |
| ebuild_path = Path( |
| tmpdir, f"virtual/rust/rust-{self.old_version}.ebuild" |
| ) |
| os.makedirs(ebuild_path.parent) |
| ebuild_path.touch() |
| with mock.patch("rust_uprev.EBUILD_PREFIX", Path(tmpdir)): |
| rust_uprev.remove_virtual_rust(self.old_version) |
| mock_call.assert_called_once_with( |
| ["git", "rm", str(ebuild_path.name)], cwd=ebuild_path.parent |
| ) |
| |
| @mock.patch.object(subprocess, "check_call") |
| def test_remove_virtual_rust_with_symlink(self, mock_call): |
| with tempfile.TemporaryDirectory() as tmpdir: |
| ebuild_path = Path( |
| tmpdir, f"virtual/rust/rust-{self.old_version}.ebuild" |
| ) |
| symlink_path = Path( |
| tmpdir, f"virtual/rust/rust-{self.old_version}-r14.ebuild" |
| ) |
| os.makedirs(ebuild_path.parent) |
| ebuild_path.touch() |
| symlink_path.symlink_to(ebuild_path.name) |
| with mock.patch("rust_uprev.EBUILD_PREFIX", Path(tmpdir)): |
| rust_uprev.remove_virtual_rust(self.old_version) |
| mock_call.assert_has_calls( |
| [ |
| mock.call( |
| ["git", "rm", ebuild_path.name], |
| cwd=ebuild_path.parent, |
| ), |
| mock.call( |
| ["git", "rm", symlink_path.name], |
| cwd=ebuild_path.parent, |
| ), |
| ], |
| any_order=True, |
| ) |
| |
| @mock.patch.object(rust_uprev, "find_ebuild_path") |
| @mock.patch.object(shutil, "copyfile") |
| @mock.patch.object(subprocess, "check_call") |
| def test_update_virtual_rust(self, mock_call, mock_copy, mock_find_ebuild): |
| ebuild_path = Path( |
| f"/some/dir/virtual/rust/rust-{self.current_version}.ebuild" |
| ) |
| mock_find_ebuild.return_value = Path(ebuild_path) |
| rust_uprev.update_virtual_rust(self.current_version, self.new_version) |
| mock_call.assert_called_once_with( |
| ["git", "add", f"rust-{self.new_version}.ebuild"], |
| cwd=ebuild_path.parent, |
| ) |
| mock_copy.assert_called_once_with( |
| ebuild_path.parent.joinpath(f"rust-{self.current_version}.ebuild"), |
| ebuild_path.parent.joinpath(f"rust-{self.new_version}.ebuild"), |
| ) |
| |
| @mock.patch("rust_uprev.find_rust_versions") |
| def test_find_oldest_rust_version_pass(self, rust_versions): |
| oldest_version_name = f"rust-{self.old_version}.ebuild" |
| rust_versions.return_value = [ |
| (self.old_version, oldest_version_name), |
| (self.current_version, f"rust-{self.current_version}.ebuild"), |
| (self.new_version, f"rust-{self.new_version}.ebuild"), |
| ] |
| actual = rust_uprev.find_oldest_rust_version() |
| expected = self.old_version |
| self.assertEqual(expected, actual) |
| |
| @mock.patch("rust_uprev.find_rust_versions") |
| def test_find_oldest_rust_version_fail_with_only_one_ebuild( |
| self, rust_versions |
| ): |
| rust_versions.return_value = [ |
| (self.new_version, f"rust-{self.new_version}.ebuild"), |
| ] |
| with self.assertRaises(RuntimeError) as context: |
| rust_uprev.find_oldest_rust_version() |
| self.assertEqual( |
| "Expect to find more than one Rust versions", str(context.exception) |
| ) |
| |
| @mock.patch.object(rust_uprev, "get_command_output") |
| @mock.patch.object(git, "CreateBranch") |
| def test_create_new_repo(self, mock_branch, mock_output): |
| mock_output.return_value = "" |
| rust_uprev.create_new_repo(self.new_version) |
| mock_branch.assert_called_once_with( |
| rust_uprev.EBUILD_PREFIX, f"rust-to-{self.new_version}" |
| ) |
| |
| @mock.patch.object(rust_uprev, "run_in_chroot") |
| def test_build_cross_compiler(self, mock_run_in_chroot): |
| cros_targets = [ |
| "x86_64-cros-linux-gnu", |
| "armv7a-cros-linux-gnueabihf", |
| "aarch64-cros-linux-gnu", |
| ] |
| all_triples = ["x86_64-pc-linux-gnu"] + cros_targets |
| rust_ebuild = "RUSTC_TARGET_TRIPLES=(" + "\n\t".join(all_triples) + ")" |
| with mock.patch("rust_uprev.find_ebuild_path") as mock_find_ebuild_path: |
| mock_path = mock.Mock() |
| mock_path.read_text.return_value = rust_ebuild |
| mock_find_ebuild_path.return_value = mock_path |
| rust_uprev.build_cross_compiler(rust_uprev.RustVersion(7, 3, 31)) |
| |
| mock_run_in_chroot.assert_called_once_with( |
| ["sudo", "emerge", "-j", "-G"] |
| + [f"cross-{x}/gcc" for x in cros_targets + ["arm-none-eabi"]] |
| ) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
