Delete public commit queue to avoid confusion after move to internal repo

commit-queue/tests/try_job_on_rietveld_test.py

Index: commit-queue/tests/try_job_on_rietveld_test.py
===================================================================
--- commit-queue/tests/try_job_on_rietveld_test.py	(revision 249146)
+++ commit-queue/tests/try_job_on_rietveld_test.py	(working copy)
@@ -1,1553 +0,0 @@
-#!/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
-import string
-import sys
-import time
-import unittest
-
-ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, os.path.join(ROOT_DIR, '..'))
-
-# In tests/
-import mocks
-from mocks import BuildbotBuildStep
-
-# In root
-from verification import base
-from verification import try_job_steps
-from verification import try_job_on_rietveld
-
-
-# Some tests produce more output if verbose, so we need to
-# track if we are in verbose mode or not.
-VERBOSE = False
-
-
-def _posted(builders):
-  return 'trigger_try_jobs(42, 23, \'CQ\', False, \'HEAD\', %s)' % str(builders)
-
-
-def gen_job_pending(**kwargs):
-  value = {
-    '__persistent_type__': 'RietveldTryJobPending',
-    'builder': None,
-    'clobber': False,
-    'init_time': 1.,
-    '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_type__': 'RietveldTryJob',
-    'build': None,
-    'builder': None,
-    'clobber': False,
-    'completed': False,
-    'init_time': 1.,
-    'parent_key': None,
-    'requested_steps': [],
-    'revision': None,
-    'started': 1,
-    'steps_failed': [],
-    'steps_passed': [],
-    'tries': 1,
-  }
-  assert all(arg in value for arg in kwargs)
-  value.update(kwargs)
-  return value
-
-
-def gen_jobs(**kwargs):
-  value =  {
-    '__persistent_type__': 'RietveldTryJobs',
-    'error_message': None,
-    'irrelevant': [],
-    'pendings': [],
-    'skipped': False,
-    'step_verifiers': [],
-    'try_jobs': {},
-  }
-  for arg in kwargs:
-    if arg not in value:
-      raise Exception('Invalid arg %s' % str(arg))
-
-  value.update(kwargs)
-
-  # Convert all the verifiers to dicts (i.e. serialize them).
-  value['step_verifiers'] = [step.as_dict() for step in value['step_verifiers']]
-
-  return value
-
-
-class TryJobOnRietveldBase(mocks.TestCase):
-  # Base class for all test cases testing try_job_rietveld.py.
-  def setUp(self):
-    super(TryJobOnRietveldBase, self).setUp()
-    self.timestamp = []
-    self.mock(time, 'time', self._time)
-    self.email = 'user1@example.com'
-    self.user = 'user1'
-    self.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='linux',
-        steps=['test1', 'test2']),
-      try_job_steps.TryJobSteps(
-        builder_name='mac',
-        steps=['test1', 'test2']),
-    ]
-
-  def tearDown(self):
-    try:
-      if not self.has_failed():
-        self.assertEqual(0, len(self.timestamp))
-    finally:
-      super(TryJobOnRietveldBase, self).tearDown()
-
-  def _time(self):
-    self.assertTrue(self.timestamp)
-    return self.timestamp.pop(0)
-
-
-class TryRunnerRietveldTest(TryJobOnRietveldBase):
-  # These test cases setup self.try_runner and call .verify() and
-  # .update_status() to test it.
-  def setUp(self):
-    super(TryRunnerRietveldTest, self).setUp()
-    self.try_runner = None
-    self._change_step_verifiers(self.step_verifiers)
-
-    # Patch it a little.
-    self.buildbot_status = mocks.BuildbotMock(self)
-    self.mock(
-        try_job_on_rietveld.buildbot_json,
-        'Buildbot',
-        lambda _: self.buildbot_status)
-
-    self.pending.revision = 123
-
-    # It's what rietveld is going to report.
-    self._key = (self.pending.issue, self.pending.patchset)
-    self.context.rietveld.patchsets_properties[self._key] = {
-      'try_job_results': [],
-    }
-
-  def tearDown(self):
-    try:
-      if not self.has_failed():
-        # Not to confuse with self.context.status which is AsyncPush mock.
-        self.buildbot_status.check_calls([])
-    finally:
-      super(TryRunnerRietveldTest, self).tearDown()
-
-  def _change_step_verifiers(self, step_verifiers):
-    """Change the current step verifiers and update any objects that used
-    the old ones."""
-    self.step_verifiers = step_verifiers
-
-    # time is requested in the object construction below and self.timestamp
-    # will be empty at the end of this function call.
-    self.timestamp.append(1.)
-    self.try_runner = try_job_on_rietveld.TryRunnerRietveld(
-        self.context,
-        'http://foo/bar',
-        self.email,
-        self.step_verifiers,
-        ['ignored_step'],
-        'sol',
-        )
-    self.try_runner.update_latency = 0
-
-
-  def _get_verif(self):
-    """Returns the RietveldTryJobs instance associated to this PendCommit."""
-    return self.pending.verifications[self.try_runner.name]
-
-  def _assert_pending_is_empty(self):
-    actual = self._get_verif().as_dict()
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'linux', requested_steps=['test1', 'test2']),
-        gen_job_pending(builder=u'mac', requested_steps=['test1', 'test2']),
-      ])
-    self.assertEqual(expected, actual)
-
-  def _add_build(self, builder, buildnumber, revision, steps, completed):
-    """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.buildbot_status.add_build(
-        builder, buildnumber, revision, key, completed, None)
-    build.steps.extend(steps)
-    self.context.rietveld.patchsets_properties[self._key][
-        'try_job_results'].append(
-          {
-            'key': key,
-            'builder': builder,
-            'buildnumber': buildnumber,
-          })
-    return key
-
-  def _add_triggered_build(self, builder, buildnumber, revision, steps,
-                           completed, parent_key):
-    """Adds a triggered 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.buildbot_status.add_build(
-        builder, buildnumber, revision, key, completed, parent_key)
-    build.steps.extend(steps)
-    self.context.rietveld.patchsets_properties[self._key][
-        'try_job_results'].append(
-          {
-            'key': key,
-            'builder': builder,
-            'buildnumber': buildnumber,
-          })
-    return key
-
-  def check_pending(self, num_status, rietveld, state, err):
-    self.context.status.check_names(['try job rietveld'] * num_status)
-    self.context.rietveld.check_calls(rietveld)
-    self.assertEqual(state, self.pending.get_state())
-    self.assertEqual(err, self.pending.error_message())
-
-  def check_verif(self, need, waiting):
-    rietveld_try_jobs = self._get_verif()
-    self.assertEqual(need, rietveld_try_jobs.tests_need_to_be_run(1.))
-    self.assertEqual(waiting, rietveld_try_jobs.tests_waiting_for_result())
-    if not waiting:
-      why_not = None
-    else:
-      why_not = (
-          'Waiting for the following jobs:\n' +
-          ''.join(
-            '  %s: %s\n' % (b, ','.join(waiting[b])) for b in sorted(waiting)))
-    self.assertEqual(why_not, rietveld_try_jobs.why_not())
-
-  def call_verify(
-      self, timestamps, num_status, rietveld, state, err, need, waiting):
-    """Calls TryRunnerRietveld.verify().
-
-    Makes sure the specified number of time.time() calls occurred.
-    """
-    self.assertEqual(0, len(self.timestamp))
-    self.timestamp = timestamps
-    self.try_runner.verify(self.pending)
-    self.assertEqual(0, len(self.timestamp))
-    self.check_pending(num_status, rietveld, state, err)
-    self.check_verif(need, waiting)
-
-  def call_update_status(
-      self, timestamps, num_status, rietveld, state, err, need, waiting):
-    """Calls TryRunnerRietveld.update_status().
-    """
-    self.timestamp = timestamps
-    self.try_runner.update_status([self.pending])
-    self.check_pending(num_status, rietveld, state, err)
-    self.check_verif(need, waiting)
-
-  def testVoid(self):
-    self.assertEqual(self.pending.verifications.keys(), [])
-    self.assertEqual(base.PROCESSING, self.pending.get_state())
-    self.assertEqual('', self.pending.error_message())
-
-  def testVoidUpdate(self):
-    self.try_runner.update_status([])
-    self.assertEqual(base.PROCESSING, self.pending.get_state())
-    self.assertEqual('', self.pending.error_message())
-
-  def testVerificationVoid(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    self._assert_pending_is_empty()
-
-  def testVerificationUpdateNoJob(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    self._assert_pending_is_empty()
-    self.call_update_status(
-        [1.] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    self._assert_pending_is_empty()
-
-  def testVerificationUpdate(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    self._assert_pending_is_empty()
-    key = self._add_build('mac', 32, 42, [], False)
-
-    self.call_update_status(
-        [1.] * (3 + 1 * VERBOSE),
-        num_status=1,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        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.assertEqual(expected, self._get_verif().as_dict())
-
-  def testVerificationSuccess(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-    key2 = self._add_build(
-        'linux', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    self.call_update_status(
-        [1.] * (4 + 2 * VERBOSE),
-        num_status=2,
-        rietveld=[],
-        state=base.SUCCEEDED,
-        err='',
-        need={},
-        waiting={})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder=u'mac',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          steps_passed=['test1', 'test2'],
-          revision=42),
-        key2: gen_job(
-          builder=u'linux',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          steps_passed=['test1', 'test2'],
-          revision=42),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testVerificationRetrySuccess(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', False)],
-        False)
-    key2 = self._add_build(
-        'linux', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    self.call_update_status(
-        [1.] * (5 + 2 * VERBOSE),
-        num_status=3,
-        rietveld=[_posted({u"mac": ["test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'mac', requested_steps=['test2'], tries=2),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder=u'mac',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          steps_failed=['test2'],
-          steps_passed=['test1'],
-          revision=42),
-        key2: gen_job(
-          builder=u'linux',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          steps_passed=['test1', 'test2'],
-          revision=42),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Add a new build on mac where test2 passed.
-    key3 = self._add_build(
-        'mac', 33, 42,
-        [BuildbotBuildStep('test1', False), BuildbotBuildStep('test2', True)],
-        False)
-    self.call_update_status(
-        [1.] * (5 + 1 * VERBOSE),
-        num_status=3,
-        rietveld=[],
-        state=base.SUCCEEDED,
-        err='',
-        need={},
-        waiting={})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      try_jobs={
-        key1: gen_job(
-          build=32,
-          builder='mac',
-          requested_steps=['test1', 'test2'],
-          steps_failed=['test2'],
-          steps_passed=['test1'],
-          revision=42),
-        key2: gen_job(
-          builder='linux',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          revision=42,
-          steps_passed=['test1', 'test2']),
-        key3: gen_job(
-          builder='mac',
-          build=33,
-          requested_steps=['test2'],
-          revision=42,
-          steps_failed=['test1'],
-          steps_passed=['test2'],
-          tries=2),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testVerificationRetryRetry(self):
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', False)],
-        False)
-    key2 = self._add_build(
-        'linux', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    self.call_update_status(
-        [1.] * (5 + 2 * VERBOSE),
-        num_status=3,
-        rietveld=[_posted({u"mac": ["test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        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(
-          builder='linux',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          steps_passed=['test1', 'test2'],
-          revision=42),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Add a new build on mac where test2 failed.
-    key3 = self._add_build('mac', 33, 42, [BuildbotBuildStep('test2', False)],
-                           False)
-
-    self.call_update_status(
-        [1.] * (6 + 1 * VERBOSE),
-        num_status=4,
-        rietveld=[_posted({u"mac": ["test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        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(
-          builder='linux',
-          build=32,
-          requested_steps=['test1', 'test2'],
-          revision=42,
-          steps_passed=['test1', 'test2']),
-        key3: gen_job(
-          builder='mac',
-          build=33,
-          requested_steps=['test2'],
-          revision=42,
-          steps_failed=['test2'],
-          tries=2),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Add a new build on mac where test2 failed again! Too bad now.
-    self._add_build('mac', 34, 42, [BuildbotBuildStep('test2', False)], False)
-
-    self.call_update_status(
-        [1.] * (6 + 2 * VERBOSE),
-        num_status=4,
-        rietveld=[],
-        state=base.FAILED,
-        err=(
-          u'Retried try job too often on mac for step(s) test2\n'
-          'http://foo/bar/buildstatus?builder=mac&number=34'),
-        need={},
-        waiting={})
-
-  def testVerificationRetryRetryTriggered(self):
-    step_verifiers = [
-        try_job_steps.TryJobTriggeredSteps(
-            builder_name='triggered',
-            trigger_name='builder',
-            steps={'test1': 'build'})]
-    self._change_step_verifiers(step_verifiers)
-
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"builder": ["build"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'triggered': ['test1']})
-
-    # The trigger bot passed, but the triggered bot fails.
-    key1 = self._add_build('builder', 1, 42, [BuildbotBuildStep('build', True)],
-                           True)
-    self._add_triggered_build('triggered', 1, 42,
-                              [BuildbotBuildStep('test1', False)], True, key1)
-    triggered_key_1 = 'triggered/1_triggered_%s' % key1
-
-    self.call_update_status(
-        [1.] * (6 + 2 * VERBOSE),
-        num_status=4,
-        rietveld=[_posted({u"builder": ["build"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'triggered': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-          try_job_steps.TryJobTriggeredSteps(
-              builder_name='triggered',
-              trigger_name='builder',
-              steps={'test1': 'build'})],
-      pendings=[
-        gen_job_pending(builder='builder', requested_steps=['build'], tries=2),
-        gen_job_pending(builder='triggered', requested_steps=['test1'],
-                        tries=2),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder='builder',
-          build=1,
-          requested_steps=['build'],
-          steps_passed=['build'],
-          completed=True,
-          revision=42,
-          tries=1,
-          ),
-        triggered_key_1: gen_job(
-          builder='triggered',
-          build=1,
-          requested_steps=['test1'],
-          steps_failed=['test1'],
-          completed=True,
-          revision=42,
-          parent_key=key1,
-          tries=1,
-          ),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Triggered bot fails again.
-    key2 = self._add_build('builder', 2, 42, [BuildbotBuildStep('build', True)],
-                           True)
-    self._add_triggered_build('triggered', 2, 42,
-                              [BuildbotBuildStep('test1', False)], True, key2)
-    triggered_key_2 = 'triggered/2_triggered_%s' % key2
-
-    self.call_update_status(
-        [1.] * (6 + 2 * VERBOSE),
-        num_status=4,
-        rietveld=[_posted({u"builder": ["build"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'triggered': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-          try_job_steps.TryJobTriggeredSteps(
-              builder_name='triggered',
-              trigger_name='builder',
-              steps={'test1': 'build'})],
-      pendings=[
-        gen_job_pending(builder='builder', requested_steps=['build'], tries=3),
-        gen_job_pending(builder='triggered', requested_steps=['test1'],
-                        tries=3),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder='builder',
-          build=1,
-          requested_steps=['build'],
-          steps_passed=['build'],
-          completed=True,
-          revision=42,
-          tries=1,
-          ),
-        triggered_key_1: gen_job(
-          builder='triggered',
-          build=1,
-          requested_steps=['test1'],
-          steps_failed=['test1'],
-          completed=True,
-          revision=42,
-          parent_key=key1,
-          tries=1,
-          ),
-        key2: gen_job(
-          builder='builder',
-          build=2,
-          requested_steps=['build'],
-          steps_passed=['build'],
-          completed=True,
-          revision=42,
-          tries=2,
-          ),
-        triggered_key_2: gen_job(
-          builder='triggered',
-          build=2,
-          requested_steps=['test1'],
-          steps_failed=['test1'],
-          completed=True,
-          revision=42,
-          parent_key=key2,
-          tries=2,
-          ),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Triggered bot fails for the 3rd time, abort.
-    key3 = self._add_build('builder', 3, 1, [BuildbotBuildStep('build', True)],
-                           True)
-    self._add_triggered_build('triggered', 3, 1,
-                              [BuildbotBuildStep('test1', False)], True, key3)
-    self.call_update_status(
-        [1.] * (4 + 3 * VERBOSE),
-        num_status=2,
-        rietveld=[],
-        state=base.FAILED,
-        # TODO(csharp): Its the triggered bot that keeps failing, so that should
-        # be the bot mentioned here.
-        err=(
-            u'Retried try job too often on builder for step(s) build\n'
-            'http://foo/bar/buildstatus?builder=builder&number=3'),
-        need={},
-        waiting={})
-
-  def testVerificationPreviousJobGood(self):
-    # Reuse the previous job if good.
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    self.call_verify(
-        [1.] * (2 + 1 * VERBOSE),
-        num_status=1,
-        rietveld=[_posted({u"linux": ["test1", "test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2']})
-
-    # Sends an update to note the job was started.
-    self.call_update_status(
-        [1.] * 3,
-        num_status=1,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        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),
-        })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def _expired(self, now, **kwargs):
-    # Exacly like testVerificationPreviousJobGood except that jobs are always
-    # too old, either by revision or by timestamp.
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    self.call_verify(
-        [now] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-
-    self.call_update_status(
-        [now] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      irrelevant=[key1],
-      pendings=[
-        gen_job_pending(
-            builder='linux', requested_steps=['test1', 'test2'], **kwargs),
-        gen_job_pending(
-            builder='mac', requested_steps=['test1', 'test2'], **kwargs),
-      ])
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testVerificationPreviousExpiredRevisionTooOld(self):
-    self.context.checkout.revisions = lambda _r1, _r2: 201
-    self._expired(1.)
-
-  def testVerificationPreviousExpiredDateTooOld(self):
-    # 5 days old.
-    old = 5*24*60*60.
-    self._expired(old, init_time=old)
-
-  def _previous_job_partially_good(
-      self, steps, steps_failed, completed, expect_mac_retry, num_time_verify,
-      num_time_update, num_status_update):
-    # Reuse the previous job tests that passed.
-    key1 = self._add_build('mac', 32, 42, steps, completed)
-
-    expected_calls = [_posted({u"linux": ["test1", "test2"]})]
-    pendings = [
-        gen_job_pending(builder='linux', requested_steps=['test1', 'test2'])
-    ]
-    if expect_mac_retry:
-      # No need to run test2 again.
-      expected_calls.append(_posted({u"mac": ["test1"]}))
-      pendings.append(gen_job_pending(builder='mac', requested_steps=['test1']))
-    self.call_verify(
-        [1.] * (num_time_verify + 1 * VERBOSE),
-        num_status=len(expected_calls),
-        rietveld=expected_calls,
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1']})
-    self.call_update_status(
-        [1.] * num_time_update,
-        num_status=num_status_update,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=pendings,
-      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.
-          tries=0,
-          completed=completed),
-        })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testVerificationPreviousJobPartiallyGood1(self):
-    # Only test1 will be run on mac since test2 had passed.
-    self._previous_job_partially_good(
-        [BuildbotBuildStep('test1', False), BuildbotBuildStep('test2', True)],
-        ['test1'], True, True, 3, 2, 0)
-
-  def testVerificationPreviousJobPartiallyGood2(self):
-    # Let's assume a testfilter was used and test1 wasn't run. Only test1 will
-    # be run on mac.
-    self._previous_job_partially_good(
-        [BuildbotBuildStep('test2', True)], [], True, True, 3, 2, 0)
-
-  def testVerificationPreviousJobPartiallyGood3(self):
-    # Test that we do not retry on mac until it completes.  This is because
-    # CQ does not parse the test filter, so we do not know if the mac job
-    # will run test1.
-    # It's kind of weird, because it sends a status report like if it had
-    # started this job.
-    self._previous_job_partially_good(
-        [BuildbotBuildStep('test2', True)], [], False, False, 2, 3, 1)
-
-  def testVerificationPreviousJobsWereGood(self):
-    # Reuse the previous jobs tests that passed. Do not send any try job.
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-    key2 = self._add_build(
-        'linux', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        False)
-
-    # People will love that!
-    self.call_verify(
-        [1.] * (1 + 2 * VERBOSE),
-        num_status=0,
-        rietveld=[],
-        state=base.SUCCEEDED,
-        err='',
-        need={},
-        waiting={})
-
-    self.call_update_status(
-        [1.],
-        num_status=0,
-        rietveld=[],
-        state=base.SUCCEEDED,
-        err='',
-        need={},
-        waiting={})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          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),
-        key2: gen_job(
-          build=32,
-          builder='linux',
-          # 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),
-        })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testRietveldTryJobsPendingWasLost(self):
-    # Requested a pending try job but the request was lost.
-    self.try_runner.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='linux',
-        steps=['test1']),
-    ]
-    self.call_verify(
-        [1.] * 2,
-        num_status=1,
-        rietveld=[_posted({u"linux": ["test1"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    self.call_update_status(
-        [1.] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-
-    # 3 minutes later
-    later = 3. * 60
-    self.call_update_status(
-        [later] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'linux', requested_steps=['test1']),
-      ])
-
-    # 1h later.
-    later = 60. * 60
-    self.call_update_status(
-        [later] * (2 + 1 * VERBOSE),
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'linux', requested_steps=['test1']),
-      ])
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testRietveldTryJobsPendingTookSomeTime(self):
-    # Requested a pending try job but the request took some time to propagate.
-    self.try_runner.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='linux',
-        steps=['test1']),
-    ]
-    self.call_verify(
-        [1.] * 2,
-        num_status=1,
-        rietveld=[_posted({u"linux": ["test1"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    self.call_update_status(
-        [1.] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    # 3 minutes later
-    later = 3. * 60
-    self.call_update_status(
-        [later] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'linux', requested_steps=['test1']),
-      ])
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Queue it.
-    self.buildbot_status.builders['linux'].pending_builds.data = [
-      {
-        "builderName":"linux",
-        "builds":[],
-        "reason":"%d-1: None" % self.pending.issue,
-        "source": {
-          "changes": [
-            {
-              "at": "Wed 05 Dec 2012 19:11:19",
-              "files": [],
-              "number": 268857,
-              "project": "",
-              "properties": [],
-              "rev": "171358",
-              "revision": "171358",
-              "when": 1354763479,
-              "who": self.pending.owner,
-            },
-          ],
-          "hasPatch": False,
-          "project": "chrome",
-          "repository": "",
-          "revision": "171358",
-        },
-        "submittedAt": 1354763479,
-      },
-    ]
-
-    # 1h later, it must not have queued another job.
-    later = 60. * 60
-    self.call_update_status(
-        [later] * 2,
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      pendings=[
-        gen_job_pending(
-            builder=u'linux', requested_steps=['test1']),
-      ])
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-  def testRietveldHung(self):
-    # Send a try job and have it never start.
-    self.try_runner.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='linux',
-        steps=['test1']),
-    ]
-    self.call_verify(
-        [1.] * 2,
-        num_status=1,
-        rietveld=[_posted({u"linux": ["test1"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-    key1 = self._add_build(
-        'linux', 32, 42,
-        [],
-        False)
-    self.call_update_status(
-        [1.] * (3 + 1 * VERBOSE),
-        num_status=1,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder=u'linux',
-          build=32,
-          requested_steps=['test1'],
-          steps_passed=[],
-          revision=42,
-          completed=False),
-      })
-
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    # Fast forward in time to make the try job request "timeout". Basically,
-    # the Try Job trigger on Rietveld was somehow ignored by the Try Server
-    # itself. Test our chance by sending another trigger.
-    later = 40. * 24 * 60 * 60
-    # Update the internal status.
-    self.call_update_status(
-        [later] * 3,
-        num_status=1,
-        rietveld=[_posted({u"linux": ["test1"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1']})
-
-    self.assertEqual(
-        'Waiting for the following jobs:\n  linux: test1\n',
-        self._get_verif().why_not())
-
-    expected_timed_out = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1']),
-      ],
-      irrelevant=[key1],
-      pendings=[
-        gen_job_pending(
-            builder=u'linux', init_time=later, requested_steps=['test1']),
-      ])
-    self.assertEqual(expected_timed_out, self._get_verif().as_dict())
-
-  def testVerificationBrokenTestOnHead(self):
-    # The CQ retries until it aborts because the test is broken at HEAD on
-    # mac/test2.
-    self.call_verify(
-        [1.] * 3,
-        num_status=2,
-        rietveld=[
-          _posted({u"linux": ["test1", "test2"]}),
-          _posted({u"mac": ["test1", "test2"]}),
-        ],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'linux': ['test1', 'test2'], 'mac': ['test1', 'test2']})
-    key1 = self._add_build(
-        'mac', 32, 42,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', False)],
-        True)
-    key2 = self._add_build(
-        'linux', 12, 22,
-        [BuildbotBuildStep('test1', True), BuildbotBuildStep('test2', True)],
-        True)
-
-    self.call_update_status(
-        [1.] * (5 + 2 * VERBOSE),
-        num_status=3,
-        rietveld=[_posted({u"mac": ["test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'mac', requested_steps=['test2'], tries=2),
-      ],
-      try_jobs={
-        key1: gen_job(
-          builder=u'mac',
-          build=32,
-          completed=True,
-          requested_steps=['test1', 'test2'],
-          steps_failed=['test2'],
-          steps_passed=['test1'],
-          revision=42),
-        key2: gen_job(
-          builder=u'linux',
-          build=12,
-          completed=True,
-          requested_steps=['test1', 'test2'],
-          steps_passed=['test1', 'test2'],
-          revision=22),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-
-    key3 = self._add_build(
-        'mac', 33, 42,
-        [BuildbotBuildStep('test2', False)],
-        True)
-    self.call_update_status(
-        [1.] * (4 + 1 * VERBOSE),
-        num_status=2,
-        rietveld=[_posted({u"mac": ["test2"]})],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-    expected = gen_jobs(
-      step_verifiers=[
-        try_job_steps.TryJobSteps(
-          builder_name='linux',
-          steps=['test1', 'test2']),
-        try_job_steps.TryJobSteps(
-          builder_name='mac',
-          steps=['test1', 'test2']),
-      ],
-      pendings=[
-        gen_job_pending(builder=u'mac', requested_steps=['test2'], tries=3),
-      ],
-      try_jobs={
-        key1: gen_job(
-          build=32,
-          builder=u'mac',
-          completed=True,
-          requested_steps=['test1', 'test2'],
-          steps_failed=['test2'],
-          steps_passed=['test1'],
-          revision=42),
-        key2: gen_job(
-          builder=u'linux',
-          build=12,
-          completed=True,
-          requested_steps=['test1', 'test2'],
-          revision=22,
-          steps_passed=['test1', 'test2']),
-        key3: gen_job(
-          builder=u'mac',
-          completed=True,
-          build=33,
-          requested_steps=['test2'],
-          revision=42,
-          steps_failed=['test2'],
-          tries=2),
-      })
-    self.assertEqual(expected, self._get_verif().as_dict())
-    self.call_update_status(
-        [1.] * (2 + 1 * VERBOSE),
-        num_status=0,
-        rietveld=[],
-        state=base.PROCESSING,
-        err='',
-        need={},
-        waiting={'mac': ['test2']})
-
-
-class RietveldTryJobsTest(TryJobOnRietveldBase):
-  # Directly test RietveldTryJobs without constructing a TryRunnerRietveld.
-  # They should never touch self.timestamp.
-  def testInitial(self):
-    now = 1.
-    jobs = try_job_on_rietveld.RietveldTryJobs()
-    jobs.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='builder1',
-        steps=['test10', 'test11']),
-    ]
-    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
-        init_time=now,
-        builder='builder1',
-        build=12,
-        revision=13,
-        requested_steps=['test10'],
-        started=int(now),
-        steps_passed=['test10'],
-        steps_failed=[],
-        clobber=False,
-        completed=True,
-        tries=1,
-        parent_key=None)
-    self.assertEqual({'builder1': ['test11']}, jobs.tests_need_to_be_run(now))
-    self.assertEqual({'builder1': ['test11']}, jobs.tests_waiting_for_result())
-
-  def testPending(self):
-    now = 1.
-    jobs = try_job_on_rietveld.RietveldTryJobs()
-    jobs.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='builder1',
-        steps=['test10', 'test11']),
-    ]
-    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
-        init_time=now,
-        builder='builder1',
-        build=12,
-        revision=13,
-        requested_steps=['test10'],
-        started=int(now),
-        steps_passed=['test10'],
-        steps_failed=[],
-        clobber=False,
-        completed=True,
-        tries=1,
-        parent_key=None)
-    jobs.pendings.append(
-        try_job_on_rietveld.RietveldTryJobPending(
-            init_time=now,
-            builder='builder1',
-            revision=13,
-            requested_steps=['test11'],
-            clobber=False,
-            tries=1))
-    self.assertEqual({}, jobs.tests_need_to_be_run(now))
-    self.assertEqual({'builder1': ['test11']}, jobs.tests_waiting_for_result())
-
-  def testTriggeredPending(self):
-    # Construct an instance that has both tests to trigger and tests that are
-    # pending results.
-    now = 1.
-    jobs = try_job_on_rietveld.RietveldTryJobs()
-    jobs.step_verifiers = [
-      try_job_steps.TryJobSteps(
-        builder_name='builder1',
-        steps=['test10', 'test11']),
-      try_job_steps.TryJobSteps(
-        builder_name='builder2',
-        steps=['test20', 'test21']),
-    ]
-    jobs.try_jobs['key1'] = try_job_on_rietveld.RietveldTryJob(
-        init_time=now,
-        builder='builder1',
-        build=12,
-        revision=13,
-        requested_steps=['test10'],
-        started=int(now),
-        steps_passed=['test10'],
-        steps_failed=[],
-        clobber=False,
-        completed=True,
-        tries=1,
-        parent_key=None)
-    jobs.try_jobs['key2'] = try_job_on_rietveld.RietveldTryJob(
-        init_time=now,
-        builder='builder2',
-        build=13,
-        revision=14,
-        requested_steps=[],
-        started=int(now),
-        steps_passed=['test21'],
-        steps_failed=[],
-        clobber=False,
-        completed=False,
-        tries=1,
-        parent_key=None)
-    jobs.pendings.append(
-        try_job_on_rietveld.RietveldTryJobPending(
-            init_time=now,
-            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.assertEqual({'builder1': ['test11']}, jobs.tests_need_to_be_run(now))
-    self.assertEqual(
-        {'builder1': ['test11'], 'builder2': ['test20']},
-        jobs.tests_waiting_for_result())
-
-  def testAddTriggeredBot(self):
-    jobs = try_job_on_rietveld.RietveldTryJobs()
-    jobs.step_verifiers = [try_job_steps.TryJobTriggeredSteps(
-        builder_name='tester1',
-        trigger_name='builder1',
-        steps={'test3': 'trigger'})]
-    self.assertEqual({'builder1': ['trigger']}, jobs.tests_need_to_be_run(1.))
-    self.assertEqual({'tester1': ['test3']}, jobs.tests_waiting_for_result())
-
-  def testGenerateWatchedBuilders(self):
-    jobs = try_job_on_rietveld.RietveldTryJobs()
-    jobs.step_verifiers = [
-        try_job_steps.TryJobSteps(
-            builder_name='builder1',
-            steps=['test']),
-        try_job_steps.TryJobTriggeredSteps(
-            builder_name='triggered1',
-            trigger_name='trigger_bot1',
-            steps={'test': 'test'}),
-        try_job_steps.TryJobTriggeredOrNormalSteps(
-            builder_name='triggered2',
-            trigger_name='trigger_bot2',
-            trigger_bot_steps=['test'],
-            steps={'test': 'test'},
-            use_triggered_bot=False)
-    ]
-
-    expected_watched_builders = [
-        'builder1',
-        'trigger_bot1',
-        'trigger_bot2',
-        'triggered1',
-        'triggered2'
-    ]
-    self.assertEqual(sorted(expected_watched_builders),
-                     sorted(jobs.watched_builders()))
-
-
-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')
-  if '-v' in sys.argv:
-    VERBOSE = True
-    unittest.TestCase.maxDiff = None
-  unittest.main()