Merge MVP script into cbuildbot.

buildbot/cbuildbot_stages_unittest.py

 #!/usr/bin/python
 
 # Copyright (c) 2011 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.
 
 """Unittests for build stages."""
 
 import mox
 import os
 import StringIO
 import sys
 import unittest
 
 import constants
 sys.path.append(constants.SOURCE_ROOT)
 import chromite.buildbot.cbuildbot as cbuildbot
 import chromite.buildbot.cbuildbot_config as config
 import chromite.buildbot.cbuildbot_commands as commands
 import chromite.buildbot.cbuildbot_stages as stages
 import chromite.lib.cros_build_lib as cros_lib
+import chromite.buildbot.manifest_version as manifest_version
 
 
 class CBuildBotTest(mox.MoxTestBase):
 
   def setUp(self):
     mox.MoxTestBase.setUp(self)
     # Always stub RunCommmand out as we use it in every method.
     self.bot_id = 'x86-generic-pre-flight-queue'
     self.build_config = config.config[self.bot_id]
 
@@ skipping 70 matching lines @@
     Implement in subclasses.
     """
     raise NotImplementedError, "return an instance of stage to be tested"
 
   def setUp(self):
     mox.MoxTestBase.setUp(self)
     # Always stub RunCommmand out as we use it in every method.
     self.bot_id = 'x86-generic-pre-flight-queue'
     self.build_config = config.config[self.bot_id]
     self.build_root = '/fake_root'
+
     self.url = 'fake_url'
+    self.build_config['git_url'] = self.url
 
     self.options = self.mox.CreateMockAnything()
     self.options.buildroot = self.build_root
     self.options.debug = False
     self.options.prebuilts = False
-    self.options.tracking_branch = 'ooga_booga'
+    self.options.tracking_branch = 'ooga/booga'
     self.options.clobber = False
-    self.options.url = self.url
     self.options.buildnumber = 1234
     self.overlay = os.path.join(self.build_root,
                                 'src/third_party/chromiumos-overlay')
     stages.BuilderStage.rev_overlays = [self.overlay]
     stages.BuilderStage.push_overlays = [self.overlay]
     self.mox.StubOutWithMock(os.path, 'isdir')
 
   def RunStage(self):
     """Creates and runs an instance of the stage to be tested.
     Requires ConstructStage() to be implemented.
@@ skipping 42 matching lines @@
       cros_lib.RunCommand(mox.And(mox.IsA(list), mox.In('--noprivate')),
                           redirect_stdout=True).AndReturn(output_obj)
       output_obj = cros_lib.CommandResult()
       output_obj.output = 'private1 private2\n'
       cros_lib.RunCommand(mox.And(mox.IsA(list), mox.In('--nopublic')), \
                           redirect_stdout=True).AndReturn(output_obj)
     self.mox.ReplayAll()
     stage = self.ConstructStage()
     public_overlays = ['public1', 'public2', self.overlay]
     private_overlays = ['private1', 'private2']
+
     self.assertEqual(stage._ResolveOverlays('public'), public_overlays)
     self.assertEqual(stage._ResolveOverlays('private'), private_overlays)
     self.assertEqual(stage._ResolveOverlays('both'),
                      public_overlays + private_overlays)
     self.mox.VerifyAll()
 
 
 class SyncStageTest(AbstractStageTest):
 
   def setUp(self):
@@ skipping 29 matching lines @@
     os.path.isdir(self.build_root + '/.repo').AndReturn(True)
     stages.BuilderStage._GetPortageEnvVar(stages._FULL_BINHOST)
     commands.IncrementalCheckout(self.build_root)
     os.path.isdir(self.overlay).AndReturn(True)
 
     self.mox.ReplayAll()
     self.RunStage()
     self.mox.VerifyAll()
 
 
+class ManifestVersionedSyncStageTest(BuilderStageTest):
+  """Tests the two (heavily related) stages ManifestVersionedSync, and
+     ManifestVersionedSyncCompleted.
+  """
+
+  def setUp(self):
+    mox.MoxTestBase.setUp(self)
+    BuilderStageTest.setUp(self)
+
+    self.manifest_version_url = 'fake manifest url'
+    self.build_config['manifest_version'] = self.manifest_version_url
+
+    self.next_version = 'next_version'
+
+
+  def testManifestVersionedSync(self):
+    """Tests basic ManifestVersionedSyncStage"""
+
+    branch = self.options.tracking_branch.split('/')
+
+    self.mox.StubOutWithMock(manifest_version, 'GenerateWorkload')
+    self.mox.StubOutWithMock(commands, 'ManifestCheckout')
+
+    os.path.isdir(self.build_root + '/.repo').AndReturn(False)
+    manifest_version.GenerateWorkload(
+       tmp_dir='/tmp/git.root',
+       source_repo=self.url,
+       manifest_repo=self.manifest_version_url,
+       branch=branch[1],
+       version_file='src/third_party/chromiumos-overlay/chromeos/config'
+                    '/chromeos_version.sh',
+       board=self.build_config['board'],
+       incr_type= 'patch',
+       debug=False).AndReturn(self.next_version)
+
+    commands.ManifestCheckout(self.build_root,
+                              self.options.tracking_branch,
+                              self.next_version,
+                              url=self.manifest_version_url)
+
+    os.path.isdir('/fake_root/src/'
+                  'third_party/chromiumos-overlay').AndReturn(True)
+
+    self.mox.ReplayAll()
+    stage = stages.ManifestVersionedSyncStage(self.bot_id,
+                                              self.options,
+                                              self.build_config)
+    stage.Run()
+    self.mox.VerifyAll()
+
+  def testManifestVersionedSyncCompletedSuccess(self):
+    """Tests basic ManifestVersionedSyncStageCompleted"""
+
+    stages.ManifestVersionedSyncStage.build_version = self.next_version
+
+    self.mox.StubOutWithMock(manifest_version, 'UpdateStatus')
+
+    os.path.isdir(self.build_root + '/.repo').AndReturn(False)
+    manifest_version.UpdateStatus(
+       tmp_dir='/tmp/git.root',
+       manifest_repo=self.manifest_version_url,
+       board=self.build_config['board'],
+       build_version=self.next_version,
+       success=True,
+       debug=False)
+
+    self.mox.ReplayAll()
+    stage = stages.ManifestVersionedSyncCompletionStage(self.bot_id,
+                                                        self.options,
+                                                        self.build_config,
+                                                        success=True)
+    stage.Run()
+    self.mox.VerifyAll()
+
+  def testManifestVersionedSyncCompletedFailure(self):
+    """Tests basic ManifestVersionedSyncStageCompleted"""
+
+    stages.ManifestVersionedSyncStage.build_version = self.next_version
+
+    self.mox.StubOutWithMock(manifest_version, 'UpdateStatus')
+
+    os.path.isdir(self.build_root + '/.repo').AndReturn(False)
+    manifest_version.UpdateStatus(
+       tmp_dir='/tmp/git.root',
+       manifest_repo=self.manifest_version_url,
+       board=self.build_config['board'],
+       build_version=self.next_version,
+       success=False,
+       debug=False)
+
+    self.mox.ReplayAll()
+    stage = stages.ManifestVersionedSyncCompletionStage(self.bot_id,
+                                                        self.options,
+                                                        self.build_config,
+                                                        success=False)
+    stage.Run()
+    self.mox.VerifyAll()
+
+  def testManifestVersionedSyncCompletedIncomplete(self):
+    """Tests basic ManifestVersionedSyncStageCompleted"""
+
+    stages.ManifestVersionedSyncStage.build_version = None
+
+    os.path.isdir(self.build_root + '/.repo').AndReturn(False)
+
+    self.mox.ReplayAll()
+    stage = stages.ManifestVersionedSyncCompletionStage(self.bot_id,
+                                                        self.options,
+                                                        self.build_config,
+                                                        success=False)
+    stage.Run()
+    self.mox.VerifyAll()
+
 class BuildBoardTest(AbstractStageTest):
 
   def setUp(self):
     mox.MoxTestBase.setUp(self)
     AbstractStageTest.setUp(self)
 
   def ConstructStage(self):
      return stages.BuildBoardStage(self.bot_id, self.options, self.build_config)
 
   def testFullBuild(self):
@@ skipping 533 matching lines @@
     actualResults = stages.BuilderStage.Results.Get()
 
     # Break out the asserts to be per item to make debugging easier
     self.assertEqual(len(expectedResults), len(actualResults))
     for i in xrange(len(expectedResults)):
       self.assertEqual(expectedResults[i], actualResults[i])
 
 
 if __name__ == '__main__':
   unittest.main()