| #!/usr/bin/python |
| |
| # Copyright (c) 2010 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 cros_mark_chrome_as_stable.py.""" |
| |
| import mox |
| import os |
| import shutil |
| import sys |
| import tempfile |
| import unittest |
| import urllib |
| |
| import constants |
| sys.path.append(constants.CROSUTILS_LIB_DIR) |
| import cros_mark_as_stable |
| import cros_mark_chrome_as_stable |
| |
| unstable_data = 'KEYWORDS=~x86 ~arm' |
| stable_data = 'KEYWORDS=x86 arm' |
| |
| def _TouchAndWrite(path, data=None): |
| """Writes data (if it exists) to the file specified by the path.""" |
| fh = open(path, 'w') |
| if data: |
| fh.write(data) |
| |
| fh.close() |
| |
| |
| class CrosMarkChromeAsStable(mox.MoxTestBase): |
| |
| def setUp(self): |
| """Setup vars and create mock dir.""" |
| mox.MoxTestBase.setUp(self) |
| self.tmp_overlay = tempfile.mkdtemp(prefix='chromiumos-overlay') |
| self.mock_chrome_dir = os.path.join(self.tmp_overlay, 'chromeos-base', |
| 'chromeos-chrome') |
| os.makedirs(self.mock_chrome_dir) |
| |
| self.unstable = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-9999.ebuild') |
| self.sticky_branch = '8.0.224' |
| self.sticky_version = '%s.503' % self.sticky_branch |
| self.sticky = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s.ebuild' % |
| self.sticky_version) |
| self.sticky_rc_version = '%s.504' % self.sticky_branch |
| self.sticky_rc = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_rc-r1.ebuild' % |
| self.sticky_rc_version) |
| self.latest_stable_version = '8.0.300.1' |
| self.latest_stable = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_rc-r2.ebuild' % |
| self.latest_stable_version) |
| self.tot_stable_version = '9.0.305.0' |
| self.tot_stable = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_alpha-r1.ebuild' % |
| self.tot_stable_version) |
| |
| self.sticky_new_rc_version = '%s.520' % self.sticky_branch |
| self.sticky_new_rc = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_rc-r1.ebuild' % |
| self.sticky_new_rc_version) |
| self.latest_new_version = '9.0.305.1' |
| self.latest_new = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_rc-r1.ebuild' % |
| self.latest_new_version) |
| self.tot_new_version = '9.0.306.0' |
| self.tot_new = os.path.join(self.mock_chrome_dir, |
| 'chromeos-chrome-%s_alpha-r1.ebuild' % |
| self.tot_new_version) |
| |
| _TouchAndWrite(self.unstable, unstable_data) |
| _TouchAndWrite(self.sticky, stable_data) |
| _TouchAndWrite(self.sticky_rc, stable_data) |
| _TouchAndWrite(self.latest_stable, stable_data) |
| _TouchAndWrite(self.tot_stable, stable_data) |
| |
| def tearDown(self): |
| """Cleans up mock dir.""" |
| shutil.rmtree(self.tmp_overlay) |
| |
| def testFindChromeCandidates(self): |
| """Test creation of stable ebuilds from mock dir.""" |
| unstable, stable_ebuilds = cros_mark_chrome_as_stable.FindChromeCandidates( |
| self.mock_chrome_dir) |
| |
| self.assertEqual(unstable.ebuild_path, self.unstable) |
| self.assertEqual(len(stable_ebuilds), 4) |
| self.assertTrue(cros_mark_chrome_as_stable.ChromeEBuild(self.sticky) in |
| stable_ebuilds) |
| self.assertTrue(cros_mark_chrome_as_stable.ChromeEBuild(self.sticky_rc) in |
| stable_ebuilds) |
| self.assertTrue(cros_mark_chrome_as_stable.ChromeEBuild(self.latest_stable) |
| in stable_ebuilds) |
| self.assertTrue(cros_mark_chrome_as_stable.ChromeEBuild(self.tot_stable) in |
| stable_ebuilds) |
| |
| def _GetStableEBuilds(self): |
| """Common helper to create a list of stable ebuilds.""" |
| return [ |
| cros_mark_chrome_as_stable.ChromeEBuild(self.sticky), |
| cros_mark_chrome_as_stable.ChromeEBuild(self.sticky_rc), |
| cros_mark_chrome_as_stable.ChromeEBuild(self.latest_stable), |
| cros_mark_chrome_as_stable.ChromeEBuild(self.tot_stable), |
| ] |
| |
| def testTOTFindChromeUprevCandidate(self): |
| """Tests if we can find tot uprev candidate from our mock dir data.""" |
| stable_ebuilds = self._GetStableEBuilds() |
| |
| candidate = cros_mark_chrome_as_stable.FindChromeUprevCandidate( |
| stable_ebuilds, cros_mark_chrome_as_stable.TIP_OF_TRUNK, |
| self.sticky_branch) |
| |
| self.assertEqual(candidate.ebuild_path, self.tot_stable) |
| |
| def testLatestFindChromeUprevCandidate(self): |
| """Tests if we can find latest uprev candidate from our mock dir data.""" |
| stable_ebuilds = self._GetStableEBuilds() |
| |
| candidate = cros_mark_chrome_as_stable.FindChromeUprevCandidate( |
| stable_ebuilds, cros_mark_chrome_as_stable.LATEST_RELEASE, |
| self.sticky_branch) |
| |
| self.assertEqual(candidate.ebuild_path, self.latest_stable) |
| |
| def testStickyFindChromeUprevCandidate(self): |
| """Tests if we can find sticky uprev candidate from our mock dir data.""" |
| stable_ebuilds = self._GetStableEBuilds() |
| |
| candidate = cros_mark_chrome_as_stable.FindChromeUprevCandidate( |
| stable_ebuilds, cros_mark_chrome_as_stable.STICKY, |
| self.sticky_branch) |
| |
| self.assertEqual(candidate.ebuild_path, self.sticky_rc) |
| |
| def testGetTipOfTrunkSvnRevision(self): |
| """Tests if we can get the latest svn revision from TOT.""" |
| self.mox.StubOutWithMock(cros_mark_chrome_as_stable, 'RunCommand') |
| cros_mark_chrome_as_stable.RunCommand( |
| ['svn', 'info', cros_mark_chrome_as_stable._GetSvnUrl()], |
| redirect_stdout=True).AndReturn( |
| 'Some Junk 2134\nRevision: 12345\nOtherInfo: test_data') |
| self.mox.ReplayAll() |
| revision = cros_mark_chrome_as_stable._GetTipOfTrunkSvnRevision() |
| self.mox.VerifyAll() |
| self.assertEquals(revision, '12345') |
| |
| def testGetTipOfTrunkVersion(self): |
| """Tests if we get the latest version from TOT.""" |
| self.mox.StubOutWithMock(urllib, 'urlopen') |
| mock_file = self.mox.CreateMock(file) |
| urllib.urlopen(os.path.join(cros_mark_chrome_as_stable._GetSvnUrl(), 'src', |
| 'chrome', 'VERSION')).AndReturn(mock_file) |
| mock_file.read().AndReturn('A=8\nB=0\nC=256\nD=0') |
| mock_file.close() |
| |
| self.mox.ReplayAll() |
| version = cros_mark_chrome_as_stable._GetTipOfTrunkVersion() |
| self.mox.VerifyAll() |
| self.assertEquals(version, '8.0.256.0') |
| |
| def testGetLatestRelease(self): |
| """Tests if we can find the latest release from our mock url data.""" |
| test_data = '\n'.join(['7.0.224.1/', |
| '7.0.224.2/', |
| '8.0.365.5/', |
| 'LATEST.txt']) |
| self.mox.StubOutWithMock(cros_mark_chrome_as_stable, 'RunCommand') |
| cros_mark_chrome_as_stable.RunCommand( |
| ['svn', 'ls', 'http://src.chromium.org/svn/releases'], |
| redirect_stdout=True).AndReturn('some_data') |
| cros_mark_chrome_as_stable.RunCommand( |
| ['sort', '--version-sort'], input='some_data', |
| redirect_stdout=True).AndReturn(test_data) |
| self.mox.ReplayAll() |
| release = cros_mark_chrome_as_stable._GetLatestRelease() |
| self.mox.VerifyAll() |
| self.assertEqual('8.0.365.5', release) |
| |
| def testGetLatestStickyRelease(self): |
| """Tests if we can find the latest sticky release from our mock url data.""" |
| test_data = '\n'.join(['7.0.222.1/', |
| '8.0.224.2/', |
| '8.0.365.5/', |
| 'LATEST.txt']) |
| self.mox.StubOutWithMock(cros_mark_chrome_as_stable, 'RunCommand') |
| cros_mark_chrome_as_stable.RunCommand( |
| ['svn', 'ls', 'http://src.chromium.org/svn/releases'], |
| redirect_stdout=True).AndReturn('some_data') |
| cros_mark_chrome_as_stable.RunCommand( |
| ['sort', '--version-sort'], input='some_data', |
| redirect_stdout=True).AndReturn(test_data) |
| self.mox.ReplayAll() |
| release = cros_mark_chrome_as_stable._GetLatestRelease(self.sticky_branch) |
| self.mox.VerifyAll() |
| self.assertEqual('8.0.224.2', release) |
| |
| def testStickyEBuild(self): |
| """Tests if we can find the sticky ebuild from our mock directories.""" |
| stable_ebuilds = self._GetStableEBuilds() |
| sticky_ebuild = cros_mark_chrome_as_stable._GetStickyEBuild( |
| stable_ebuilds) |
| self.assertEqual(sticky_ebuild.chrome_version, self.sticky_version) |
| |
| def testChromeEBuildInit(self): |
| """Tests if the chrome_version is set correctly in a ChromeEBuild.""" |
| ebuild = cros_mark_chrome_as_stable.ChromeEBuild(self.sticky) |
| self.assertEqual(ebuild.chrome_version, self.sticky_version) |
| |
| def _CommonMarkAsStableTest(self, chrome_rev, new_version, old_ebuild_path, |
| new_ebuild_path, commit_string_indicator): |
| """Common function used for test functions for MarkChromeEBuildAsStable. |
| |
| This function stubs out others calls, and runs MarkChromeEBuildAsStable |
| with the specified args. |
| |
| Args: |
| chrome_rev: standard chrome_rev argument |
| new_version: version we are revving up to |
| old_ebuild_path: path to the stable ebuild |
| new_ebuild_path: path to the to be created path |
| commit_string_indicator: a string that the commit message must contain |
| """ |
| self.mox.StubOutWithMock(cros_mark_chrome_as_stable, 'RunCommand') |
| self.mox.StubOutWithMock(cros_mark_as_stable.EBuildStableMarker, |
| 'CommitChange') |
| stable_candidate = cros_mark_chrome_as_stable.ChromeEBuild(old_ebuild_path) |
| unstable_ebuild = cros_mark_chrome_as_stable.ChromeEBuild(self.unstable) |
| sticky_ebuild = cros_mark_chrome_as_stable.ChromeEBuild(self.sticky) |
| chrome_version = new_version |
| commit = None |
| overlay_dir = self.mock_chrome_dir |
| |
| cros_mark_chrome_as_stable.RunCommand(['git', 'add', new_ebuild_path]) |
| cros_mark_chrome_as_stable.RunCommand(['git', 'rm', old_ebuild_path]) |
| cros_mark_as_stable.EBuildStableMarker.CommitChange( |
| mox.StrContains(commit_string_indicator)) |
| |
| self.mox.ReplayAll() |
| cros_mark_chrome_as_stable.MarkChromeEBuildAsStable( |
| stable_candidate, unstable_ebuild, chrome_rev, chrome_version, commit, |
| overlay_dir, sticky_ebuild) |
| self.mox.VerifyAll() |
| |
| def testStickyMarkAsStable(self): |
| """Tests to see if we can mark chrome as stable for a new sticky release.""" |
| self._CommonMarkAsStableTest(cros_mark_chrome_as_stable.STICKY, |
| self.sticky_new_rc_version, self.sticky_rc, |
| self.sticky_new_rc, 'stable_release') |
| |
| def testLatestMarkAsStable(self): |
| """Tests to see if we can mark chrome for a latest release.""" |
| self._CommonMarkAsStableTest(cros_mark_chrome_as_stable.LATEST_RELEASE, |
| self.latest_new_version, self.latest_stable, |
| self.latest_new, 'latest_release') |
| |
| def testTotMarkAsStable(self): |
| """Tests to see if we can mark chrome for tot.""" |
| self._CommonMarkAsStableTest(cros_mark_chrome_as_stable.TIP_OF_TRUNK, |
| self.tot_new_version, self.tot_stable, |
| self.tot_new, 'tot') |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
