Add chrome revving module to crosutils

bin/cros_mark_chrome_as_stable_unittest.py

Index: bin/cros_mark_chrome_as_stable_unittest.py
diff --git a/bin/cros_mark_chrome_as_stable_unittest.py b/bin/cros_mark_chrome_as_stable_unittest.py
new file mode 100755
index 0000000000000000000000000000000000000000..ab16cd68ea5eaa6b369942df4ec27d38a483c584
--- /dev/null
+++ b/bin/cros_mark_chrome_as_stable_unittest.py
@@ -0,0 +1,269 @@
+#!/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 cros_mark_chrome_as_stable
+import mox
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+import urllib
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+import cros_mark_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 testStickyVersion(self):
+    """Tests if we can find the sticky version from our mock directories."""
+    stable_ebuilds = self._GetStableEBuilds()
+    sticky_version = cros_mark_chrome_as_stable._GetStickyVersion(
+        stable_ebuilds)
+    self.assertEqual(sticky_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)
+    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)
+    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, 'sticky_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()