src/third_party/chromite/buildbot/manifest_version_unittest.py

   1 #!/usr/bin/python
   2
   3 # Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 """Unittests for manifest_version. Needs to be run inside of chroot for mox."""
   8
   9 import os
  10 import sys
  11 import tempfile
  12
  13 import constants
  14 if __name__ == '__main__':
  15   sys.path.insert(0, constants.SOURCE_ROOT)
  16
  17 from chromite.buildbot import manifest_version
  18 from chromite.buildbot import repository
  19 from chromite.lib import git
  20 from chromite.lib import cros_test_lib
  21 from chromite.lib import osutils
  22
  23 # pylint: disable=W0212,R0904
  24 FAKE_VERSION = """
  25 CHROMEOS_BUILD=%(build_number)s
  26 CHROMEOS_BRANCH=%(branch_build_number)s
  27 CHROMEOS_PATCH=%(patch_number)s
  28 CHROME_BRANCH=%(chrome_branch)s
  29 """
  30
  31 FAKE_VERSION_STRING = '1.2.3'
  32 FAKE_VERSION_STRING_NEXT = '1.2.4'
  33 CHROME_BRANCH = '13'
  34
  35 # Use the chromite repo to actually test git changes.
  36 GIT_TEST_PATH = 'chromite'
  37
  38
  39 class HelperMethodsTest(cros_test_lib.TempDirTestCase):
  40   """Test methods associated with methods not in a class."""
  41
  42   def testCreateSymlink(self):
  43     """Tests that we can create symlinks and remove a previous one."""
  44     srcfile = os.path.join(self.tempdir, 'src')
  45     osutils.Touch(srcfile)
  46     other_dir = os.path.join(self.tempdir, 'other_dir')
  47     os.makedirs(other_dir)
  48     destfile = os.path.join(other_dir, 'dest')
  49
  50     manifest_version.CreateSymlink(srcfile, destfile)
  51     self.assertTrue(os.path.lexists(destfile),
  52                     'Unable to create symlink to %s' % destfile)
  53
  54
  55 class VersionInfoTest(cros_test_lib.MoxTempDirTestCase):
  56   """Test methods testing methods in VersionInfo class."""
  57
  58   @classmethod
  59   def WriteFakeVersionFile(cls, version_file, version=None, chrome_branch=None):
  60     """Helper method to write a version file from specified version number."""
  61     if version is None:
  62       version = FAKE_VERSION_STRING
  63     if chrome_branch is None:
  64       chrome_branch = CHROME_BRANCH
  65
  66     osutils.SafeMakedirs(os.path.split(version_file)[0])
  67     info = manifest_version.VersionInfo(version, chrome_branch)
  68     osutils.WriteFile(version_file, FAKE_VERSION % info.__dict__)
  69
  70   @classmethod
  71   def CreateFakeVersionFile(cls, tmpdir, version=None, chrome_branch=None):
  72     """Helper method to create a version file from specified version number."""
  73     version_file = tempfile.mktemp(dir=tmpdir)
  74     cls.WriteFakeVersionFile(version_file, version=version,
  75                              chrome_branch=chrome_branch)
  76     return version_file
  77
  78   def testLoadFromFile(self):
  79     """Tests whether we can load from a version file."""
  80     version_file = self.CreateFakeVersionFile(self.tempdir)
  81     info = manifest_version.VersionInfo(version_file=version_file)
  82     self.assertEqual(info.VersionString(), FAKE_VERSION_STRING)
  83
  84   def testLoadFromRepo(self):
  85     """Tests whether we can load from a source repo."""
  86     version_file = os.path.join(self.tempdir, constants.VERSION_FILE)
  87     self.WriteFakeVersionFile(version_file)
  88     info = manifest_version.VersionInfo.from_repo(self.tempdir)
  89     self.assertEqual(info.VersionString(), FAKE_VERSION_STRING)
  90
  91   def testLoadFromString(self):
  92     """Tests whether we can load from a string."""
  93     info = manifest_version.VersionInfo(FAKE_VERSION_STRING, CHROME_BRANCH)
  94     self.assertEqual(info.VersionString(), FAKE_VERSION_STRING)
  95
  96   def CommonTestIncrementVersion(self, incr_type, version, chrome_branch=None):
  97     """Common test increment.  Returns path to new incremented file."""
  98     message = 'Incrementing cuz I sed so'
  99     self.mox.StubOutWithMock(git, 'CreateBranch')
 100     self.mox.StubOutWithMock(manifest_version, '_PushGitChanges')
 101     self.mox.StubOutWithMock(git, 'CleanAndCheckoutUpstream')
 102
 103     git.CreateBranch(self.tempdir, manifest_version.PUSH_BRANCH)
 104
 105     version_file = self.CreateFakeVersionFile(
 106         self.tempdir, version=version, chrome_branch=chrome_branch)
 107
 108     manifest_version._PushGitChanges(self.tempdir, message, dry_run=False,
 109                                      push_to=None)
 110
 111     git.CleanAndCheckoutUpstream(self.tempdir)
 112     self.mox.ReplayAll()
 113     info = manifest_version.VersionInfo(version_file=version_file,
 114                                         incr_type=incr_type)
 115     info.IncrementVersion()
 116     info.UpdateVersionFile(message, dry_run=False)
 117     self.mox.VerifyAll()
 118     return version_file
 119
 120   def testIncrementVersionPatch(self):
 121     """Tests whether we can increment a version file by patch number."""
 122     version_file = self.CommonTestIncrementVersion('branch', '1.2.3')
 123     new_info = manifest_version.VersionInfo(version_file=version_file,
 124                                             incr_type='branch')
 125     self.assertEqual(new_info.VersionString(), '1.2.4')
 126
 127   def testIncrementVersionBranch(self):
 128     """Tests whether we can increment a version file by branch number."""
 129     version_file = self.CommonTestIncrementVersion('branch', '1.2.0')
 130     new_info = manifest_version.VersionInfo(version_file=version_file,
 131                                             incr_type='branch')
 132     self.assertEqual(new_info.VersionString(), '1.3.0')
 133
 134   def testIncrementVersionBuild(self):
 135     """Tests whether we can increment a version file by build number."""
 136     version_file = self.CommonTestIncrementVersion('build', '1.0.0')
 137     new_info = manifest_version.VersionInfo(version_file=version_file,
 138                                             incr_type='build')
 139     self.assertEqual(new_info.VersionString(), '2.0.0')
 140
 141   def testIncrementVersionChrome(self):
 142     """Tests whether we can increment the chrome version."""
 143     version_file = self.CommonTestIncrementVersion(
 144         'chrome_branch', version='1.0.0', chrome_branch='29')
 145     new_info = manifest_version.VersionInfo(version_file=version_file)
 146     self.assertEqual(new_info.VersionString(), '2.0.0')
 147     self.assertEqual(new_info.chrome_branch, '30')
 148
 149
 150 class BuildSpecsManagerTest(cros_test_lib.MoxTempDirTestCase):
 151   """Tests for the BuildSpecs manager."""
 152
 153   def setUp(self):
 154     os.makedirs(os.path.join(self.tempdir, '.repo'))
 155     self.source_repo = 'ssh://source/repo'
 156     self.manifest_repo = 'ssh://manifest/repo'
 157     self.version_file = 'version-file.sh'
 158     self.branch = 'master'
 159     self.build_names = ['x86-generic']
 160     self.incr_type = 'branch'
 161
 162     repo = repository.RepoRepository(
 163       self.source_repo, self.tempdir, self.branch)
 164     self.manager = manifest_version.BuildSpecsManager(
 165       repo, self.manifest_repo, self.build_names, self.incr_type, False,
 166       branch=self.branch, dry_run=True)
 167
 168     # Change default to something we clean up.
 169     self.tmpmandir = os.path.join(self.tempdir, "man")
 170     osutils.SafeMakedirs(self.tmpmandir)
 171     self.manager.manifest_dir = self.tmpmandir
 172
 173   def testLoadSpecs(self):
 174     """Tests whether we can load specs correctly."""
 175     info = manifest_version.VersionInfo(
 176         FAKE_VERSION_STRING, CHROME_BRANCH, incr_type='branch')
 177     mpath = os.path.join(self.manager.manifest_dir, 'buildspecs', CHROME_BRANCH)
 178     m1, m2, m3, m4 = [os.path.join(mpath, '1.2.%d.xml' % x)
 179                       for x in [2,3,4,5]]
 180     for_build = os.path.join(self.manager.manifest_dir, 'build-name',
 181                              self.build_names[0])
 182
 183     # Create fake buildspecs.
 184     osutils.SafeMakedirs(os.path.join(mpath))
 185     for m in [m1, m2, m3, m4]:
 186       osutils.Touch(m)
 187
 188     # Fake BuilderStatus with status MISSING.
 189     missing = manifest_version.BuilderStatus(
 190         manifest_version.BuilderStatus.STATUS_MISSING, None)
 191
 192     # Fail 1, pass 2, leave 3,4 unprocessed.
 193     manifest_version.CreateSymlink(m1, os.path.join(
 194         for_build, 'fail', CHROME_BRANCH, os.path.basename(m1)))
 195     manifest_version.CreateSymlink(m1, os.path.join(
 196         for_build, 'pass', CHROME_BRANCH, os.path.basename(m2)))
 197     self.mox.StubOutWithMock(self.manager, 'GetBuildStatus')
 198     self.manager.GetBuildStatus(self.build_names[0], '1.2.5').AndReturn(missing)
 199     self.mox.ReplayAll()
 200     self.manager.InitializeManifestVariables(info)
 201     self.mox.VerifyAll()
 202     self.assertEqual(self.manager.latest_unprocessed, '1.2.5')
 203
 204   def testLatestSpecFromDir(self):
 205     """Tests whether we can get sorted specs correctly from a directory."""
 206     self.mox.StubOutWithMock(repository, 'CloneGitRepo')
 207     info = manifest_version.VersionInfo(
 208         '99.1.2', CHROME_BRANCH, incr_type='branch')
 209
 210     specs_dir = os.path.join(self.manager.manifest_dir, 'buildspecs',
 211                              CHROME_BRANCH)
 212     m1, m2, m3, m4 = [os.path.join(specs_dir, x)
 213                       for x in ['100.0.0.xml', '99.3.3.xml', '99.1.10.xml',
 214                                 '99.1.5.xml']]
 215
 216     # Create fake buildspecs.
 217     osutils.SafeMakedirs(specs_dir)
 218     for m in [m1, m2, m3, m4]:
 219       osutils.Touch(m)
 220
 221     self.mox.ReplayAll()
 222     spec = self.manager._LatestSpecFromDir(info, specs_dir)
 223     self.mox.VerifyAll()
 224     # Should be the latest on the 99.1 branch.
 225     self.assertEqual(spec, '99.1.10')
 226
 227   def testGetNextVersionNoIncrement(self):
 228     """Tests whether we can get the next version to be built correctly.
 229
 230     Tests without pre-existing version in manifest dir.
 231     """
 232     info = manifest_version.VersionInfo(
 233         FAKE_VERSION_STRING, CHROME_BRANCH, incr_type='branch')
 234
 235     self.manager.latest = None
 236     self.mox.ReplayAll()
 237     version = self.manager.GetNextVersion(info)
 238     self.mox.VerifyAll()
 239     self.assertEqual(FAKE_VERSION_STRING, version)
 240
 241   def testGetNextVersionIncrement(self):
 242     """Tests that we create a new version if a previous one exists."""
 243     self.mox.StubOutWithMock(manifest_version.VersionInfo, 'UpdateVersionFile')
 244     version_file = VersionInfoTest.CreateFakeVersionFile(self.tempdir)
 245     info = manifest_version.VersionInfo(version_file=version_file,
 246                                         incr_type='branch')
 247     info.UpdateVersionFile(
 248         'Automatic: %s - Updating to a new version number from %s' % (
 249             self.build_names[0], FAKE_VERSION_STRING), dry_run=True)
 250
 251     self.manager.latest = FAKE_VERSION_STRING
 252     self.mox.ReplayAll()
 253     version = self.manager.GetNextVersion(info)
 254     self.mox.VerifyAll()
 255     self.assertEqual(FAKE_VERSION_STRING_NEXT, version)
 256
 257   def NotestGetNextBuildSpec(self):
 258     """Meta test.  Re-enable if you want to use it to do a big test."""
 259     print self.manager.GetNextBuildSpec(retries=0)
 260     print self.manager.UpdateStatus('pass')
 261
 262   def testUnpickleBuildStatus(self):
 263     """Tests that _UnpickleBuildStatus returns the correct values."""
 264     failed_input_status = manifest_version.BuilderStatus(
 265         manifest_version.BuilderStatus.STATUS_FAILED, 'you failed!')
 266     passed_input_status = manifest_version.BuilderStatus(
 267         manifest_version.BuilderStatus.STATUS_PASSED, 'you passed!')
 268
 269     failed_output_status = self.manager._UnpickleBuildStatus(
 270         failed_input_status.AsPickledDict())
 271     passed_output_status = self.manager._UnpickleBuildStatus(
 272         passed_input_status.AsPickledDict())
 273     empty_string_status = self.manager._UnpickleBuildStatus('')
 274
 275     self.assertEqual(failed_input_status.AsFlatDict(),
 276                 failed_output_status.AsFlatDict())
 277     self.assertEqual(passed_input_status.AsFlatDict(),
 278                 passed_output_status.AsFlatDict())
 279     self.assertTrue(empty_string_status.Failed())
 280
 281
 282 if __name__ == '__main__':
 283   cros_test_lib.main()