Add priority groups to local paths in the dependency manager.

tools/telemetry/catapult_base/dependency_manager/dependency_manager_unittest.py

 # Copyright 2015 The Chromium 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 os
 import stat
 import unittest
 
 import mock
 
@@ skipping 622 matching lines @@
     self.assertEqual('dep_info2d', dep_manager._GetDependencyInfo(
         'dep2', 'missing_plat'))
     # Dependency and platform in the dependency manager. A default exists.
     self.assertEqual('dep_info23', dep_manager._GetDependencyInfo(
         'dep2', 'plat3'))
     # Dependency and platform in the dependency manager. No default exists.
     self.assertEqual('dep_info12', dep_manager._GetDependencyInfo(
         'dep1', 'plat2'))
 
 
-  @mock.patch('os.path.exists')
-  def testLocalPathHelper(self, exists_mock):
-    dep_info = mock.MagicMock(spec=dependency_manager.DependencyInfo)
 
+class TestLocalPath(fake_filesystem_unittest.TestCase):
+  def setUp(self):
+    self.setUpPyfakefs()
+    self.config_path = '/bar/test/dep_config.json'
+    # local_path0 doesn't exist locally.
+    self.local_path0 = '/foo/local_path0'
+    # local_path[1-4] exist locally and have been modified in increasing order.
+    self.local_path1 = '/foo/local_path1'
+    self.local_path2 = '/bar/local_path2'
+    self.local_path3 = '/baz/local_path3'
+    self.local_path4 = '/foo/local_path4'
+    self.fs.CreateFile(self.config_path, contents='{}')
+    file1 = self.fs.CreateFile(self.local_path1, contents='1010110',
+                               st_mode=stat.S_IWOTH)
+    file2 = self.fs.CreateFile(self.local_path2, contents='1010110',
+                               st_mode=stat.S_IWOTH)
+    file3 = self.fs.CreateFile(self.local_path3, contents='1010110',
+                               st_mode=stat.S_IWOTH)
+    file4 = self.fs.CreateFile(self.local_path4, contents='1010110',
+                               st_mode=stat.S_IWOTH)
+    file2.SetMTime(file1.st_mtime + 1)
+    file3.SetMTime(file1.st_mtime + 2)
+    file4.SetMTime(file1.st_mtime + 3)
+
+  def testLocalPathHelper(self):
     # There is no local path for the given dependency.

[eakuefner, 2015/10/09 16:29:17]

Can you put each of these cases into a separate unit test, having names that
match what's given in these comments? It seems like having so many different
cases lumped together will make repairing breakages more painful than if each of
these were a separate test.

-    dep_info.local_paths = {}
+    dep_info = dependency_manager.DependencyInfo('dep', 'plat', 'config')
+    self.assertFalse(dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    # There is a local path for the given dependency, but it doesn't exist.
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=[self.local_path0])
     self.assertEqual(None,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
 
-    # There is a local path for the given dependency, but it doesn't exist.
-    exists_mock.side_effect = [False]
-    dep_info.local_paths = {'local_path0'}
-    self.assertEqual(None,
+    # There is a local path for the given dependency, and it does exist.
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=[self.local_path1])
+    self.assertEqual(self.local_path1,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
-    exists_mock.assert_called_once_with('local_path0')
-    exists_mock.reset_mock()
-
-    # There is a local path for the given dependency, and it does exist.
-    exists_mock.side_effect = [True]
-    dep_info.local_paths = {'local_path0'}
-    self.assertEqual('local_path0',
-                     dependency_manager.DependencyManager._LocalPath(dep_info))
-    exists_mock.assert_called_once_with('local_path0')
-    exists_mock.reset_mock()
 
     # There are multiple local paths for the given dependency, and the first one
     # exists.
-    exists_mock.side_effect = [True]
-    dep_info.local_paths = {'local_path0', 'local_path1', 'local_path2'}
-    self.assertEqual('local_path0',
+    local_paths = [self.local_path1, self.local_path2, self.local_path3]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path1,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
-    exists_mock.assert_called_once_with('local_path0')
-    exists_mock.reset_mock()
 
     # There are multiple local paths for the given dependency, and the first one
-    # doesn't exist but the second one does.
-    exists_mock.side_effect = [False, True]
-    dep_info.local_paths = {'local_path0', 'local_path1', 'local_path2'}
-    self.assertEqual('local_path1',
+    # doesn't exist but the second and third do, created in order.
+    local_paths = [self.local_path0, self.local_path1, self.local_path2]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path1,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
-    expected_calls = [mock.call('local_path0'), mock.call('local_path1')]
-    exists_mock.assert_has_calls(expected_calls, any_order=False)
-    exists_mock.reset_mock()
+
+    # There are multiple local paths for the given dependency, and the first one
+    # doesn't exist but the second and third do, created in reverse order.
+    local_paths = [self.local_path0, self.local_path3, self.local_path2,
+                   self.local_path1]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path3,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
 
     # There are multiple local paths for the given dependency, and the first and
     # second ones don't exist but the third one does.
-    exists_mock.side_effect = [False, False, True]
-    dep_info.local_paths = {'local_path0', 'local_path1', 'local_path2'}
-    self.assertEqual('local_path2',
+    local_paths = ['/nope/local_path0', '/nope/local_path1', self.local_path2]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path2,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
-    expected_calls = [mock.call('local_path0'), mock.call('local_path1'),
-                      mock.call('local_path2')]
-    exists_mock.assert_has_calls(expected_calls, any_order=False)
-    exists_mock.reset_mock()
 
     # There are multiple local paths for the given dependency, but none of them
     # exist.
-    exists_mock.side_effect = [False, False, False]
-    dep_info.local_paths = {'local_path0', 'local_path1', 'local_path2'}
+    local_paths = ['/nope/local_path0', '/nope/local_path1',
+                   '/nope/local_path2']
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
     self.assertEqual(None,
                      dependency_manager.DependencyManager._LocalPath(dep_info))
-    expected_calls = [mock.call('local_path0'), mock.call('local_path1'),
-                      mock.call('local_path2')]
-    exists_mock.assert_has_calls(expected_calls, any_order=False)
-    exists_mock.reset_mock()
+
+  def testLocalPathHelperWithPriorityGroups(self):
+    # There is a local path in a priority group for the given dependency, but it
+    # doesn't exist.
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=[[self.local_path0]])
+    self.assertEqual(None,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    # There is a local path in a priority group for the given dependency, and it
+    # does exist.
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=[[self.local_path1]])
+    self.assertEqual(self.local_path1,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [self.local_path1, [self.local_path2, self.local_path3]]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path1,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [self.local_path0, [self.local_path2, self.local_path3]]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path3,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [[self.local_path1, self.local_path2], self.local_path3]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path2,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [[self.local_path2, self.local_path1, self.local_path4],
+                   self.local_path3]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path4,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = ['/nope/local_path0', ['/nope/local_path1', self.local_path2],
+                   self.local_path3]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path2,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [['/nope/local_path0', '/nope/local_path1'], self.local_path2]
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(self.local_path2,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
+
+    local_paths = [['/nope/local_path0', '/nope/local_path1'],
+                   '/nope/local_path2']
+    dep_info = dependency_manager.DependencyInfo(
+        'dep', 'plat', 'config', local_paths=local_paths)
+    self.assertEqual(None,
+                     dependency_manager.DependencyManager._LocalPath(dep_info))
 
 
 class TestCloudStoragePath(fake_filesystem_unittest.TestCase):
   def setUp(self):
     self.setUpPyfakefs()
     self.config_path = '/test/dep_config.json'
     self.fs.CreateFile(self.config_path, contents='{}')
     self.download_path = '/foo/download_path'
     self.fs.CreateFile(
         self.download_path, contents='1010110', st_mode=stat.S_IWOTH)
@@ skipping 57 matching lines @@
 
     cs_get_mock.side_effect = cloud_storage.PermissionError
     self.assertRaises(
         cloud_storage.PermissionError,
         dependency_manager.DependencyManager._CloudStoragePath, self.dep_info)
 
     cs_get_mock.side_effect = cloud_storage.CredentialsError
     self.assertRaises(
         cloud_storage.CredentialsError,
         dependency_manager.DependencyManager._CloudStoragePath, self.dep_info)