Update prebuilt to use cros_overlay_list as the definitive answer for which overlay to modify.

prebuilt_unittest.py

 #!/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.
 
 import copy
 import mox
 import os
 import prebuilt
 import shutil
@@ skipping 177 matching lines @@
     pkgs = [{ 'CPV': 'public1' }]
     result = prebuilt.GenerateUploadDict(base_local_path, gs_bucket_path, pkgs)
     expected = { local_path: gs_bucket_path + '/public1.tbz2' }
     self.assertEqual(result, expected)
 
   def testFailonUploadFail(self):
     """Make sure we fail if one of the upload processes fail."""
     files = {'test': '/uasd'}
     self.assertEqual(prebuilt.RemoteUpload(files), set([('test', '/uasd')]))
 
+  def testDeterminePrebuiltConfHost(self):
+    """Test that the host prebuilt path comes back properly."""
+    expected_path = os.path.join(prebuilt._PREBUILT_MAKE_CONF['amd64'])
+    self.assertEqual(prebuilt.DeterminePrebuiltConfFile('fake_path', 'amd64'),
+                     expected_path)
+
   def testDeterminePrebuiltConf(self):
     """Test the different known variants of boards for proper path discovery."""
-    targets = {'amd64': os.path.join(prebuilt._PREBUILT_MAKE_CONF['amd64']),
-               'x86-generic': os.path.join(prebuilt._BINHOST_BASE_DIR,
-                                        'overlay-x86-generic', 'prebuilt.conf'),
-               'arm-tegra2_vogue': os.path.join(
-                    prebuilt._BINHOST_BASE_DIR,
-                    'overlay-variant-arm-tegra2-vogue', 'prebuilt.conf'),}
-    for target in targets:
-      self.assertEqual(prebuilt.DeterminePrebuiltConfFile(target),
-                       targets[target])
+    fake_path = '/b/cbuild'
+    script_path = os.path.join(fake_path, 'src/scripts/bin')
+    public_overlay_path = os.path.join(fake_path, 'src/overlays')
+    private_overlay_path = os.path.join(fake_path,
+                                        prebuilt._PRIVATE_OVERLAY_DIR)
+    path_dict = {'private_overlay_path': private_overlay_path,
+                 'public_overlay_path': public_overlay_path}
+    # format for targets
+    # board target key in dictionar
+    # Tuple containing cmd run, expected results as cmd obj, and expected output
 
-  def testPrivatePrebuiltConf(self):
-    """Test that we get a different path for private prebuilts"""
-    targets = {'amd64': os.path.join(prebuilt._PREBUILT_MAKE_CONF['amd64']),
-               'x86-generic': os.path.join(
-                   prebuilt._PRIVATE_OVERLAY_DIR, 'overlay-x86-generic',
-                   'prebuilt.conf'),
-               'arm-tegra2_vogue': os.path.join(
-                    prebuilt._PRIVATE_OVERLAY_DIR,
-                    'overlay-variant-arm-tegra2-vogue', 'prebuilt.conf'),}
+    # Mock output from cros_overlay_list
+    x86_out = ('%(private_overlay_path)s//chromeos-overlay\n'

[sosa, 2011/01/19 22:16:52]

Dbl slash?

[scottz, 2011/01/19 22:21:24]

Oh snap :) thanks

On 2011/01/19 22:16:52, sosa wrote:

+               '%(public_overlay_path)s/overlay-x86-generic\n' % path_dict)
 
-    self.mox.StubOutWithMock(prebuilt.os.path, 'exists')
-    # Add mocks for every target we check
-    for mock_count in range(len(targets)):
-      prebuilt.os.path.exists(prebuilt._PRIVATE_OVERLAY_DIR).AndReturn(True)
+    x86_cmd = './cros_overlay_list --board x86-generic'
+    x86_expected_path = os.path.join(public_overlay_path, 'overlay-x86-generic',
+                                     'prebuilt.conf')
+    # Mock output from cros_overlay_list
+    tegra2_out = ('%(private_overlay_path)s/chromeos-overlay\n'
+                  '%(public_overlay_path)s/overlay-tegra2\n'
+                  '%(public_overlay_path)s/overlay-variant-tegra2-seaboard\n'
+                  '%(private_overlay_path)s/overlay-tegra2-private\n'
+                  '%(private_overlay_path)s/'
+                  'overlay-variant-tegra2-seaboard-private\n' % path_dict)
+    tegra2_cmd = './cros_overlay_list --board tegra2 --variant seaboard'
+    tegra2_expected_path = os.path.join(
+        private_overlay_path, 'overlay-variant-tegra2-seaboard-private',
+        'prebuilt.conf')
+
+
+    targets = {'x86-generic': {'cmd': x86_cmd,
+                               'output': x86_out,
+                               'result': x86_expected_path},
+              'tegra2_seaboard': {'cmd': tegra2_cmd,
+                                  'output': tegra2_out,
+                                  'result': tegra2_expected_path}
+              }
+
+    self.mox.StubOutWithMock(prebuilt.cros_build_lib, 'RunCommand')
+    for target, expected_results in targets.iteritems():
+      # create command object for output
+      cmd_result_obj = cros_build_lib.CommandResult()
+      cmd_result_obj.output = expected_results['output']
+      prebuilt.cros_build_lib.RunCommand(
+        expected_results['cmd'].split(), redirect_stdout=True,
+        cwd=script_path).AndReturn(cmd_result_obj)
+      
     self.mox.ReplayAll()
-
-    for target in targets:
-      self.assertEqual(prebuilt.DeterminePrebuiltConfFile(target),
-                       targets[target])
+    for target, expected_results in targets.iteritems():
+      self.assertEqual(
+        prebuilt.DeterminePrebuiltConfFile(fake_path, target),
+        expected_results['result'])
 
   def testDeterminePrebuiltConfGarbage(self):
     """Ensure an exception is raised on bad input."""
     self.assertRaises(prebuilt.UnknownBoardFormat,
-                      prebuilt.DeterminePrebuiltConfFile, 'asdfasdf')
+                      prebuilt.DeterminePrebuiltConfFile,
+                      'fake_path', 'asdfasdf')
 
 
 class TestPackagesFileFiltering(unittest.TestCase):
 
   def testFilterPkgIndex(self):
     pkgindex = SimplePackageIndex()
     pkgindex.RemoveFilteredPackages(lambda pkg: pkg in PRIVATE_PACKAGES)
     self.assertEqual(pkgindex.packages, PUBLIC_PACKAGES)
     self.assertEqual(pkgindex.modified, True)
 
@@ skipping 87 matching lines @@
     pkgindex = SimplePackageIndex()
     self.mox.StubOutWithMock(pkgindex, 'Write')
     pkgindex.Write(mox.IgnoreArg())
     self.mox.ReplayAll()
     f = pkgindex.WriteToNamedTemporaryFile()
     self.assertEqual(f.read(), '')
 
 
 if __name__ == '__main__':
   unittest.main()