| # Copyright 2015 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. |
| |
| """This module tests the brillo sdk command.""" |
| |
| from __future__ import print_function |
| |
| import mock |
| import os |
| |
| from chromite.cbuildbot import constants |
| from chromite.cbuildbot import repository |
| from chromite.cli import command_unittest |
| from chromite.cli.brillo import brillo_sdk |
| from chromite.lib import bootstrap_lib |
| from chromite.lib import commandline |
| from chromite.lib import cros_build_lib_unittest |
| from chromite.lib import cros_test_lib |
| from chromite.lib import gs |
| from chromite.lib import gs_unittest |
| from chromite.lib import osutils |
| from chromite.lib import project_sdk |
| from chromite.lib import workspace_lib |
| |
| # Unittests often access internals. |
| # pylint: disable=protected-access |
| |
| |
| class MockSdkCommand(command_unittest.MockCommand): |
| """Mock out the `brillo sdk` command.""" |
| TARGET = 'chromite.cli.brillo.brillo_sdk.SdkCommand' |
| TARGET_CLASS = brillo_sdk.SdkCommand |
| COMMAND = 'sdk' |
| |
| def __init__(self, *args, **kwargs): |
| command_unittest.MockCommand.__init__(self, *args, **kwargs) |
| |
| def Run(self, inst): |
| return command_unittest.MockCommand.Run(self, inst) |
| |
| |
| class BrilloSdkTest(cros_test_lib.MockTempDirTestCase): |
| """Test class for our BuildCommand class.""" |
| |
| def setUp(self): |
| # Avoid self-updating for most tests. |
| os.environ[brillo_sdk._BRILLO_SDK_NO_UPDATE] = '1' |
| |
| self.bootstrap_path = os.path.join(self.tempdir, 'bootstrap') |
| self.sdk_path = os.path.join(self.tempdir, 'sdk') |
| self.workspace_path = os.path.join(self.tempdir, 'workspace') |
| osutils.SafeMakedirs(self.workspace_path) |
| |
| def fakeRepoRoot(d): |
| bootstrap_checkouts = os.path.join(self.bootstrap_path, |
| bootstrap_lib.SDK_CHECKOUTS) |
| if d.startswith(self.sdk_path) or d.startswith(bootstrap_checkouts): |
| return d |
| return None |
| |
| self.PatchObject(project_sdk, 'FindRepoRoot', side_effect=fakeRepoRoot) |
| |
| # Prevent actually downloading a repository. |
| self.mock_repo = self.PatchObject(repository, 'RepoRepository') |
| |
| # Prevent actual GS interaction. |
| self.gs_mock = self.StartPatcher(gs_unittest.GSContextMock()) |
| self.gs_mock.SetDefaultCmdResult() |
| |
| # Looking up the 'latest' version from GS will return 4.5.6 |
| self.latest_version = '4.5.6' |
| self.gs_mock.AddCmdResult( |
| ['cat', constants.BRILLO_LATEST_RELEASE_URL], |
| output=self.latest_version) |
| |
| def testResolveLatest(self): |
| result = brillo_sdk._ResolveLatest(gs.GSContext()) |
| self.assertEqual(self.latest_version, result) |
| |
| def testUpdateWorkspaceSdk(self): |
| brillo_sdk._UpdateWorkspaceSdk( |
| gs.GSContext(), self.bootstrap_path, self.workspace_path, '1.2.3') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(mock.ANY, |
| os.path.join(self.tempdir, |
| 'bootstrap/sdk_checkouts/1.2.3'), |
| depth=1), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| def testUpdateSdk(self): |
| brillo_sdk._UpdateSdk(gs.GSContext(), self.sdk_path, '1.2.3') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(mock.ANY, |
| self.sdk_path, |
| depth=1), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| # Verify that the right version number was written out. |
| sdk_version_file = project_sdk.VersionFile(self.sdk_path) |
| self.assertEqual('1.2.3', osutils.ReadFile(sdk_version_file)) |
| |
| |
| def testHandleExplicitUpdate(self): |
| brillo_sdk._HandleUpdate( |
| self.bootstrap_path, None, self.sdk_path, '1.2.3') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(mock.ANY, |
| self.sdk_path, |
| depth=1), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| def testHandleLatestUpdate(self): |
| brillo_sdk._HandleUpdate( |
| self.bootstrap_path, None, self.sdk_path, 'latest') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(mock.ANY, |
| self.sdk_path, |
| depth=1), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| def testHandleTotUpdate(self): |
| brillo_sdk._HandleUpdate( |
| self.bootstrap_path, None, self.sdk_path, 'tot') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(constants.MANIFEST_URL, |
| self.sdk_path, |
| manifest=constants.PROJECT_MANIFEST), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| def testHandleWorkspaceUpdate(self): |
| brillo_sdk._HandleUpdate( |
| self.bootstrap_path, self.workspace_path, None, '1.2.3') |
| |
| # Given the explicit path and version, sync what we expect, and where. |
| expected = [mock.call(mock.ANY, |
| os.path.join(self.tempdir, |
| 'bootstrap/sdk_checkouts/1.2.3'), |
| depth=1), |
| mock.call().Sync()] |
| |
| self.assertEqual(expected, self.mock_repo.mock_calls) |
| |
| def testFindVersion(self): |
| # Fake out the workspace version. |
| workspace_version = 'work_version' |
| self.PatchObject(workspace_lib, 'GetActiveSdkVersion', |
| return_value=workspace_version) |
| |
| # Fake out the SDK version. |
| sdk_version = 'sdk version' |
| osutils.SafeMakedirs(self.sdk_path) |
| sdk_version_file = project_sdk.VersionFile(self.sdk_path) |
| osutils.WriteFile(sdk_version_file, sdk_version) |
| |
| # If we only know the workspace, use the workspace version. |
| self.assertEqual( |
| workspace_version, brillo_sdk._FindVersion(self.workspace_path, None)) |
| |
| # If we have an explicit sdk path, use it's version. |
| self.assertEqual( |
| sdk_version, |
| brillo_sdk._FindVersion(None, self.sdk_path)) |
| |
| self.assertEqual( |
| sdk_version, |
| brillo_sdk._FindVersion(self.workspace_path, self.sdk_path)) |
| |
| class BrilloSdkTestSelfUpdate(cros_test_lib.MockTempDirTestCase): |
| """Test the self-update functionality of brillo_sdk. |
| |
| This is a new class, to avoid mocks interferring with each other. |
| """ |
| def setUp(self): |
| if brillo_sdk._BRILLO_SDK_NO_UPDATE in os.environ: |
| del os.environ[brillo_sdk._BRILLO_SDK_NO_UPDATE] |
| |
| self.bootstrap_path = os.path.join(self.tempdir, 'bootstrap') |
| |
| self.rc_mock = self.StartPatcher(cros_build_lib_unittest.RunCommandMock()) |
| self.rc_mock.SetDefaultCmdResult() |
| |
| def testSelfUpdate(self): |
| with self.assertRaises(commandline.ExecRequiredError): |
| brillo_sdk._SelfUpdate(self.bootstrap_path) |
| |
| # Test we did the git pull before raising.... |
| self.rc_mock.assertCommandContains( |
| ['git', 'pull'], cwd=self.bootstrap_path) |
| |
| # Test we updated our env before raising.... |
| self.assertIn(brillo_sdk._BRILLO_SDK_NO_UPDATE, os.environ) |
| |
| def testSelfAlreadyUpdated(self): |
| # Mark that we already updated. |
| os.environ[brillo_sdk._BRILLO_SDK_NO_UPDATE] = '1' |
| |
| # Try to update again (no exception raised). |
| brillo_sdk._SelfUpdate(self.bootstrap_path) |
| |
| # Test we didn't run a git pull. |
| self.assertEquals(0, self.rc_mock.call_count) |
| |
| |
| class BrilloSdkCommandTest(cros_test_lib.MockTempDirTestCase): |
| """Test class for our BuildCommand class.""" |
| |
| def setUp(self): |
| if brillo_sdk._BRILLO_SDK_NO_UPDATE in os.environ: |
| del os.environ[brillo_sdk._BRILLO_SDK_NO_UPDATE] |
| |
| self.cmd_mock = None |
| |
| # Workspace is supposed to exist in advance. |
| self.sdk_path = os.path.join(self.tempdir, 'sdk') |
| |
| # Fake it out, so the SDK appears to be a repo, but bootstrap doesn't. |
| self.PatchObject( |
| project_sdk, 'FindRepoRoot', |
| side_effect=lambda d: d if d.startswith(self.sdk_path) else None) |
| |
| # Prevent actually downloading a repository. |
| self.mock_repo = self.PatchObject(repository, 'RepoRepository') |
| |
| def SetupCommandMock(self, cmd_args): |
| """Sets up the command mock.""" |
| self.cmd_mock = MockSdkCommand(cmd_args) |
| self.StartPatcher(self.cmd_mock) |
| |
| def testHandleSelfUpdateAndRestart(self): |
| self.SetupCommandMock(['--update', 'latest', '--sdk-dir', self.sdk_path]) |
| |
| with self.assertRaises(commandline.ExecRequiredError): |
| self.cmd_mock.inst.Run() |
| |
| def testHandleVersionOnlyNoUpdate(self): |
| self.SetupCommandMock(['--sdk-dir', self.sdk_path]) |
| |
| # Write out a version to find. |
| osutils.SafeMakedirs(self.sdk_path) |
| sdk_version_file = project_sdk.VersionFile(self.sdk_path) |
| osutils.WriteFile(sdk_version_file, 'test version') |
| |
| # Make sure no exec assertion is raised if we aren't updating. |
| self.cmd_mock.inst.Run() |
| |
| def testHandleSelfUpdateAfterRestart(self): |
| os.environ[brillo_sdk._BRILLO_SDK_NO_UPDATE] = '1' |
| self.SetupCommandMock(['--update', 'latest', '--sdk-dir', self.sdk_path]) |
| |
| # Make sure no exec assertion is raised. |
| self.cmd_mock.inst.Run() |
