[Android] Redesigns the sharder to allow replicated vs distributed tests

build/android/pylib/base/dispatch_unittest.py

 # Copyright (c) 2012 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.
 
-"""Unittests for shard.py."""
+"""Unittests for dispatch.py."""
 
 import os
 import sys
 import unittest
 
 sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)),
                 os.pardir, os.pardir))
 
 # Mock out android_commands.GetAttachedDevices().
 from pylib import android_commands
 android_commands.GetAttachedDevices = lambda: ['0', '1']
 from pylib import constants
 from pylib.utils import watchdog_timer
 
 import base_test_result
-import shard
+import dispatch
 
 
 class TestException(Exception):
   pass
 
 
 class MockRunner(object):
   """A mock TestRunner."""
   def __init__(self, device='0', shard_index=0):
     self.device = device
@@ skipping 39 matching lines @@
           test, base_test_result.ResultType.PASS))
       return (results, None)
 
 
 class MockRunnerException(MockRunner):
   def RunTest(self, test):
     raise TestException
 
 
 class TestFunctions(unittest.TestCase):
-  """Tests for shard._RunTestsFromQueue."""
+  """Tests for dispatch._RunTestsFromQueue."""
   @staticmethod
   def _RunTests(mock_runner, tests):
     results = []
-    tests = shard._TestCollection([shard._Test(t) for t in tests])
-    shard._RunTestsFromQueue(mock_runner, tests, results,
-                             watchdog_timer.WatchdogTimer(None), 2)
+    tests = dispatch._TestCollection([dispatch._Test(t) for t in tests])
+    dispatch._RunTestsFromQueue(mock_runner, tests, results,
+                                watchdog_timer.WatchdogTimer(None), 2)
     run_results = base_test_result.TestRunResults()
     for r in results:
       run_results.AddTestRunResults(r)
     return run_results
 
   def testRunTestsFromQueue(self):
     results = TestFunctions._RunTests(MockRunner(), ['a', 'b'])
     self.assertEqual(len(results.GetPass()), 2)
     self.assertEqual(len(results.GetNotPass()), 0)
 
   def testRunTestsFromQueueRetry(self):
     results = TestFunctions._RunTests(MockRunnerFail(), ['a', 'b'])
     self.assertEqual(len(results.GetPass()), 0)
     self.assertEqual(len(results.GetFail()), 2)
 
   def testRunTestsFromQueueFailTwice(self):
     results = TestFunctions._RunTests(MockRunnerFailTwice(), ['a', 'b'])
     self.assertEqual(len(results.GetPass()), 2)
     self.assertEqual(len(results.GetNotPass()), 0)
 
   def testSetUp(self):
     runners = []
-    counter = shard._ThreadSafeCounter()
-    shard._SetUp(MockRunner, '0', runners, counter)
+    counter = dispatch._ThreadSafeCounter()
+    dispatch._SetUp(MockRunner, '0', runners, counter)
     self.assertEqual(len(runners), 1)
     self.assertEqual(runners[0].setups, 1)
 
   def testThreadSafeCounter(self):
-    counter = shard._ThreadSafeCounter()
+    counter = dispatch._ThreadSafeCounter()
     for i in xrange(5):
       self.assertEqual(counter.GetAndIncrement(), i)
 
 
 class TestThreadGroupFunctions(unittest.TestCase):
-  """Tests for shard._RunAllTests and shard._CreateRunners."""
+  """Tests for dispatch._RunAllTests and dispatch._CreateRunners."""
   def setUp(self):
     self.tests = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+    shared_test_collection = dispatch._TestCollection(
+        [dispatch._Test(t) for t in self.tests])
+    self.test_collection_factory = lambda: shared_test_collection
 
   def testCreate(self):
-    runners = shard._CreateRunners(MockRunner, ['0', '1'])
+    runners = dispatch._CreateRunners(MockRunner, ['0', '1'])
     for runner in runners:
       self.assertEqual(runner.setups, 1)
     self.assertEqual(set([r.device for r in runners]),
                      set(['0', '1']))
     self.assertEqual(set([r.shard_index for r in runners]),
                      set([0, 1]))
 
   def testRun(self):
     runners = [MockRunner('0'), MockRunner('1')]
-    results, exit_code = shard._RunAllTests(runners, self.tests, 0)
+    results, exit_code = dispatch._RunAllTests(
+        runners, self.test_collection_factory, 0)
     self.assertEqual(len(results.GetPass()), len(self.tests))
     self.assertEqual(exit_code, 0)
 
   def testTearDown(self):
     runners = [MockRunner('0'), MockRunner('1')]
-    shard._TearDownRunners(runners)
+    dispatch._TearDownRunners(runners)
     for runner in runners:
       self.assertEqual(runner.teardowns, 1)
 
   def testRetry(self):
-    runners = shard._CreateRunners(MockRunnerFail, ['0', '1'])
-    results, exit_code = shard._RunAllTests(runners, self.tests, 0)
+    runners = dispatch._CreateRunners(MockRunnerFail, ['0', '1'])
+    results, exit_code = dispatch._RunAllTests(
+        runners, self.test_collection_factory, 0)
     self.assertEqual(len(results.GetFail()), len(self.tests))
     self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
 
   def testReraise(self):
-    runners = shard._CreateRunners(MockRunnerException, ['0', '1'])
+    runners = dispatch._CreateRunners(MockRunnerException, ['0', '1'])
     with self.assertRaises(TestException):
-      shard._RunAllTests(runners, self.tests, 0)
+      dispatch._RunAllTests(runners, self.test_collection_factory, 0)
 
 
 class TestShard(unittest.TestCase):
-  """Tests for shard.Shard."""
+  """Tests for dispatch.ShardAndRunTests."""
   @staticmethod
   def _RunShard(runner_factory):
-    return shard.ShardAndRunTests(runner_factory, ['0', '1'], ['a', 'b', 'c'])
+    return dispatch.ShardAndRunTests(['a', 'b', 'c'], False, None,
+                                     runner_factory)
 
   def testShard(self):
     results, exit_code = TestShard._RunShard(MockRunner)
     self.assertEqual(len(results.GetPass()), 3)
     self.assertEqual(exit_code, 0)
 
   def testFailing(self):
     results, exit_code = TestShard._RunShard(MockRunnerFail)
     self.assertEqual(len(results.GetPass()), 0)
     self.assertEqual(len(results.GetFail()), 3)
-    self.assertEqual(exit_code, 0)
+    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
 
   def testNoTests(self):
-    results, exit_code = shard.ShardAndRunTests(MockRunner, ['0', '1'], [])
+    results, exit_code = dispatch.ShardAndRunTests([], False, None, MockRunner)
     self.assertEqual(len(results.GetAll()), 0)
     self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
 
+
+class TestReplicate(unittest.TestCase):
+  """Tests for dispatch.ReplicateAndRunTests."""
+  @staticmethod
+  def _RunReplicate(runner_factory):
+    return dispatch.ReplicateAndRunTests(['a', 'b', 'c'], False, None,
+                                         runner_factory)
+
+  def testReplicate(self):
+    results, exit_code = TestReplicate._RunReplicate(MockRunner)
+    # We expect 6 results since each test should have been run on every device
+    self.assertEqual(len(results.GetPass()), 6)
+    self.assertEqual(exit_code, 0)
+
+  def testFailing(self):
+    results, exit_code = TestReplicate._RunReplicate(MockRunnerFail)
+    self.assertEqual(len(results.GetPass()), 0)
+    self.assertEqual(len(results.GetFail()), 6)
+    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+
+  def testNoTests(self):
+    results, exit_code = dispatch.ReplicateAndRunTests([], False, None,
+                                                       MockRunner)
+    self.assertEqual(len(results.GetAll()), 0)
+    self.assertEqual(exit_code, constants.ERROR_EXIT_CODE)
+
 
 if __name__ == '__main__':
   unittest.main()