Differentiate between tests that needs to be run or need to wait for completion.

tests/try_job_on_rietveld_test.py

 #!/usr/bin/env python
 # 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.
 
 """Unit tests for verification/try_job_on_rietveld.py."""
 
 import logging
 import os
 import random
@@ skipping 55 matching lines @@
   def add_build(self, builder, number, revision, key):
     """Add a build to a builder."""
     self.builders[builder].builds[number] = BuildbotBuild(revision, key)
     return self.builders[builder].builds[number]
 
 
 def _posted(builders):
   return 'trigger_try_jobs(42, 23, \'CQ\', False, None, %s)' % str(builders)
 
 
+def gen_job_pending(**kwargs):
+  value = {
+    '__persistent_module__': 'verification.try_job_on_rietveld',
+    '__persistent_type__': 'RietveldTryJobPending',
+    'builder': None,
+    'clobber': False,
+    'requested_steps': [],
+    'revision': None,
+    'tries': 1,
+  }
+  assert all(arg in value for arg in kwargs)
+  value.update(kwargs)
+  return value
+
+
 def gen_job(**kwargs):
   value = {
     '__persistent_module__': 'verification.try_job_on_rietveld',
     '__persistent_type__': 'RietveldTryJob',
     'build': None,
     'builder': None,
     'clobber': False,
     'completed': False,
     'requested_steps': [],
     'revision': None,
@@ skipping 62 matching lines @@
     return self.pending.verifications[self.try_runner.name]
 
   def _assert_pending_is_empty(self):
     actual = self._get_verif().as_dict()
     expected =  gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='linux', requested_steps=['test1', 'test2']),
-        gen_job(builder='mac', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='linux', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='mac', requested_steps=['test1', 'test2']),
       ])
     self.assertEquals(expected, actual)
 
   def _add_build(self, builder, buildnumber, revision, steps):
     """Adds a build with a randomly generated key.
 
     Adds the build to both the try server and to Rietveld.
     """
     key = ''.join(random.choice(string.ascii_letters) for _ in xrange(8))
     build = self.try_runner.status.add_build(
@@ skipping 55 matching lines @@
         ])
     key = self._add_build('mac', 32, 42, [])
 
     self.try_runner.update_status([self.pending])
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='linux', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='linux', requested_steps=['test1', 'test2']),
       ],
       try_jobs={
         key: gen_job(
           builder='mac',
           build=32,
           requested_steps=['test1', 'test2'],
           revision=42),
       })
     self.assertEquals(expected, self._get_verif().as_dict())
     self.context.status.check_names(['try job rietveld'] * 1)
@@ skipping 55 matching lines @@
         'linux', 32, 42,
         [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)])
 
     self.try_runner.update_status([self.pending])
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='mac', requested_steps=['test2'], tries=2),
+        gen_job_pending(builder='mac', requested_steps=['test2'], tries=2),
       ],
       try_jobs={
         key1: gen_job(
           builder='mac',
           build=32,
           requested_steps=['test1', 'test2'],
           steps_failed=['test2'],
           steps_passed=['test1'],
           revision=42),
         key2: gen_job(
@@ skipping 64 matching lines @@
         'linux', 32, 42,
         [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)])
 
     self.try_runner.update_status([self.pending])
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='mac', requested_steps=['test2'], tries=2),
+        gen_job_pending(builder='mac', requested_steps=['test2'], tries=2),
       ],
       try_jobs={
         key1: gen_job(
           builder='mac',
           build=32,
           requested_steps=['test1', 'test2'],
           steps_failed=['test2'],
           steps_passed=['test1'],
           revision=42),
         key2: gen_job(
@@ skipping 15 matching lines @@
     key3 = self._add_build('mac', 33, 42, [BuildbotBuildStep('test2', False)])
 
     self.try_runner.update_status([self.pending])
     self.context.status.check_names(['try job rietveld'] * 2)
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='mac', requested_steps=['test2'], tries=3),
+        gen_job_pending(builder='mac', requested_steps=['test2'], tries=3),
       ],
       try_jobs={
         key1: gen_job(
           build=32,
           builder='mac',
           requested_steps=['test1', 'test2'],
           steps_failed=['test2'],
           steps_passed=['test1'],
           revision=42),
         key2: gen_job(
@@ skipping 40 matching lines @@
           _posted({"linux": ["test1", "test2"]}),
         ])
 
     self.try_runner.update_status([self.pending])
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='linux', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='linux', requested_steps=['test1', 'test2']),
       ],
       try_jobs={
         key1: gen_job(
           build=32,
           builder='mac',
           # Note that requested_steps is empty since testfilter is not parsed.
           steps_passed=['test1', 'test2'],
           revision=42,
           # tries == 0 since we didn't start it.
           tries=0),
@@ skipping 11 matching lines @@
 
     self.try_runner.verify(self.pending)
     self.context.status.check_names(['try job rietveld'] * 2)
     self.context.rietveld.check_calls(
         [
           _posted({"linux": ["test1", "test2"]}),
           _posted({"mac": ["test1", "test2"]}),
         ])
 
     self.try_runner.update_status([self.pending])
-    # self.timestamp is a mock for time.time()
-    started = self.timestamp[-1]
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       irrelevant=[key1],
       pendings=[
-        gen_job(
-            builder='linux',
-            requested_steps=['test1', 'test2'],
-            started=started),
-        gen_job(
-            builder='mac',
-            requested_steps=['test1', 'test2'],
-            started=started),
+        gen_job_pending(builder='linux', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='mac', requested_steps=['test1', 'test2']),
       ])
     self.assertEquals(expected, self._get_verif().as_dict())
     self.assertEquals(base.PROCESSING, self.pending.get_state())
     self.assertEquals('', self.pending.error_message())
 
   def testVerificationPreviousExpiredRevisionTooOld(self):
     self.context.checkout.revisions = lambda _r1, _r2: 201
     self._expired()
 
   def testVerificationPreviousExpiredDateTooOld(self):
@@ skipping 14 matching lines @@
           _posted({"mac": ["test1"]}),
         ])
 
     self.try_runner.update_status([self.pending])
     expected = gen_jobs(
       builders_and_tests={
         'linux': ['test1', 'test2'],
         'mac': ['test1', 'test2'],
       },
       pendings=[
-        gen_job(builder='linux', requested_steps=['test1', 'test2']),
-        gen_job(builder='mac', requested_steps=['test1']),
+        gen_job_pending(builder='linux', requested_steps=['test1', 'test2']),
+        gen_job_pending(builder='mac', requested_steps=['test1']),
       ],
       try_jobs={
         key1: gen_job(
           build=32,
           builder='mac',
           # Note that requested_steps is empty since testfilter is not parsed.
           steps_failed=steps_failed,
           steps_passed=['test2'],
           revision=42,
           # tries == 0 since we didn't start it.
@@ skipping 49 matching lines @@
           steps_passed=['test1', 'test2'],
           revision=42,
           # tries == 0 since we didn't start it.
           tries=0),
         })
     self.assertEquals(expected, self._get_verif().as_dict())
     # People will love that!
     self.assertEquals(base.SUCCEEDED, self.pending.get_state())
     self.assertEquals('', self.pending.error_message())
 
+  def testRietveldTryJobs_1(self):
+    jobs = try_job_on_rietveld.RietveldTryJobs()
+    jobs.builders_and_tests['builder1'] = ['test10', 'test11']
+    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
+        builder='builder1',
+        build=12,
+        revision=13,
+        requested_steps=['test10'],
+        started=time.time(),
+        passed=['test10'],
+        failed=[],
+        clobber=False,
+        completed=True,
+        tries=1)
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_need_to_be_run())
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_waiting_for_result())
+
+  def testRietveldTryJobs_2(self):
+    jobs = try_job_on_rietveld.RietveldTryJobs()
+    jobs.builders_and_tests['builder1'] = ['test10', 'test11']
+    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
+        'builder1',
+        12,
+        13,
+        ['test10'],
+        time.time(),
+        ['test10'],
+        [],
+        False,
+        True,
+        1)
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_need_to_be_run())
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_waiting_for_result())
+
+  def testRietveldTryJobs_3(self):
+    jobs = try_job_on_rietveld.RietveldTryJobs()
+    jobs.builders_and_tests['builder1'] = ['test10', 'test11']
+    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
+        builder='builder1',
+        build=12,
+        revision=13,
+        requested_steps=['test10'],
+        started=time.time(),
+        passed=['test10'],
+        failed=[],
+        clobber=False,
+        completed=True,
+        tries=1)
+    jobs.pendings.append(
+        try_job_on_rietveld.RietveldTryJobPending(
+            builder='builder1',
+            revision=13,
+            requested_steps=['test11'],
+            clobber=False,
+            tries=1))
+    self.assertEquals({}, jobs.tests_need_to_be_run())
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_waiting_for_result())
+
+  def testRietveldTryJobs_4(self):
+    # Construct an instance that has both tests to trigger and tests that are
+    # pending results.
+    jobs = try_job_on_rietveld.RietveldTryJobs()
+    jobs.builders_and_tests = {
+      'builder1': ['test10', 'test11'],
+      'builder2': ['test20', 'test21'],
+    }
+    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
+        builder='builder1',
+        build=12,
+        revision=13,
+        requested_steps=['test10'],
+        started=time.time(),
+        passed=['test10'],
+        failed=[],
+        clobber=False,
+        completed=True,
+        tries=1)
+    jobs.try_jobs['key2'] = try_job_on_rietveld.RietveldTryJob(
+        builder='builder2',
+        build=13,
+        revision=14,
+        requested_steps=[],
+        started=time.time(),
+        passed=['test21'],
+        failed=[],
+        clobber=False,
+        completed=False,
+        tries=1)
+    jobs.pendings.append(
+        try_job_on_rietveld.RietveldTryJobPending(
+            builder='builder2',
+            revision=14,
+            requested_steps=['test20'],
+            clobber=False,
+            tries=1))
+    # test11 is still not queued to be run but build with test20 in it has still
+    # not started yet.
+    self.assertEquals({'builder1': ['test11']}, jobs.tests_need_to_be_run())
+    self.assertEquals(
+        {'builder1': ['test11'], 'builder2': ['test20']},
+        jobs.tests_waiting_for_result())
+
 
 if __name__ == '__main__':
   logging.basicConfig(
       level=[logging.WARNING, logging.INFO, logging.DEBUG][
         min(sys.argv.count('-v'), 2)],
       format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
   unittest.main()