Tools/Scripts/webkitpy/tool/bot/queueengine_unittest.py

   1 # Copyright (c) 2009 Google Inc. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or without
   4 # modification, are permitted provided that the following conditions are
   5 # met:
   6 #
   7 #     * Redistributions of source code must retain the above copyright
   8 # notice, this list of conditions and the following disclaimer.
   9 #     * Redistributions in binary form must reproduce the above
  10 # copyright notice, this list of conditions and the following disclaimer
  11 # in the documentation and/or other materials provided with the
  12 # distribution.
  13 #     * Neither the name of Google Inc. nor the names of its
  14 # contributors may be used to endorse or promote products derived from
  15 # this software without specific prior written permission.
  16 #
  17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 import datetime
  30 import os
  31 import shutil
  32 import tempfile
  33 import threading
  34 import unittest2 as unittest
  35
  36 from webkitpy.common.system.executive import ScriptError
  37 from webkitpy.common.system.outputcapture import OutputCapture
  38 from webkitpy.tool.bot.queueengine import QueueEngine, QueueEngineDelegate, TerminateQueue
  39
  40
  41 class LoggingDelegate(QueueEngineDelegate):
  42     def __init__(self, test):
  43         self._test = test
  44         self._callbacks = []
  45         self._run_before = False
  46         self.stop_message = None
  47
  48     expected_callbacks = [
  49         'queue_log_path',
  50         'begin_work_queue',
  51         'should_continue_work_queue',
  52         'next_work_item',
  53         'work_item_log_path',
  54         'process_work_item',
  55         'should_continue_work_queue',
  56         'stop_work_queue',
  57     ]
  58
  59     def record(self, method_name):
  60         self._callbacks.append(method_name)
  61
  62     def queue_log_path(self):
  63         self.record("queue_log_path")
  64         return os.path.join(self._test.temp_dir, "queue_log_path")
  65
  66     def work_item_log_path(self, work_item):
  67         self.record("work_item_log_path")
  68         return os.path.join(self._test.temp_dir, "work_log_path", "%s.log" % work_item)
  69
  70     def begin_work_queue(self):
  71         self.record("begin_work_queue")
  72
  73     def should_continue_work_queue(self):
  74         self.record("should_continue_work_queue")
  75         if not self._run_before:
  76             self._run_before = True
  77             return True
  78         return False
  79
  80     def next_work_item(self):
  81         self.record("next_work_item")
  82         return "work_item"
  83
  84     def process_work_item(self, work_item):
  85         self.record("process_work_item")
  86         self._test.assertEqual(work_item, "work_item")
  87         return True
  88
  89     def handle_unexpected_error(self, work_item, message):
  90         self.record("handle_unexpected_error")
  91         self._test.assertEqual(work_item, "work_item")
  92
  93     def stop_work_queue(self, message):
  94         self.record("stop_work_queue")
  95         self.stop_message = message
  96
  97
  98 class RaisingDelegate(LoggingDelegate):
  99     def __init__(self, test, exception):
 100         LoggingDelegate.__init__(self, test)
 101         self._exception = exception
 102
 103     def process_work_item(self, work_item):
 104         self.record("process_work_item")
 105         raise self._exception
 106
 107
 108 class FastQueueEngine(QueueEngine):
 109     def __init__(self, delegate):
 110         QueueEngine.__init__(self, "fast-queue", delegate, threading.Event())
 111
 112     # No sleep for the wicked.
 113     seconds_to_sleep = 0
 114
 115     def _sleep(self, message):
 116         pass
 117
 118
 119 class QueueEngineTest(unittest.TestCase):
 120     def test_trivial(self):
 121         delegate = LoggingDelegate(self)
 122         self._run_engine(delegate)
 123         self.assertEqual(delegate.stop_message, "Delegate terminated queue.")
 124         self.assertEqual(delegate._callbacks, LoggingDelegate.expected_callbacks)
 125         self.assertTrue(os.path.exists(os.path.join(self.temp_dir, "queue_log_path")))
 126         self.assertTrue(os.path.exists(os.path.join(self.temp_dir, "work_log_path", "work_item.log")))
 127
 128     def test_unexpected_error(self):
 129         delegate = RaisingDelegate(self, ScriptError(exit_code=3))
 130         self._run_engine(delegate)
 131         expected_callbacks = LoggingDelegate.expected_callbacks[:]
 132         work_item_index = expected_callbacks.index('process_work_item')
 133         # The unexpected error should be handled right after process_work_item starts
 134         # but before any other callback.  Otherwise callbacks should be normal.
 135         expected_callbacks.insert(work_item_index + 1, 'handle_unexpected_error')
 136         self.assertEqual(delegate._callbacks, expected_callbacks)
 137
 138     def test_handled_error(self):
 139         delegate = RaisingDelegate(self, ScriptError(exit_code=QueueEngine.handled_error_code))
 140         self._run_engine(delegate)
 141         self.assertEqual(delegate._callbacks, LoggingDelegate.expected_callbacks)
 142
 143     def _run_engine(self, delegate, engine=None, termination_message=None):
 144         if not engine:
 145             engine = QueueEngine("test-queue", delegate, threading.Event())
 146         if not termination_message:
 147             termination_message = "Delegate terminated queue."
 148         expected_logs = "\n%s\n" % termination_message
 149         OutputCapture().assert_outputs(self, engine.run, expected_logs=expected_logs)
 150
 151     def _test_terminating_queue(self, exception, termination_message):
 152         work_item_index = LoggingDelegate.expected_callbacks.index('process_work_item')
 153         # The terminating error should be handled right after process_work_item.
 154         # There should be no other callbacks after stop_work_queue.
 155         expected_callbacks = LoggingDelegate.expected_callbacks[:work_item_index + 1]
 156         expected_callbacks.append("stop_work_queue")
 157
 158         delegate = RaisingDelegate(self, exception)
 159         self._run_engine(delegate, termination_message=termination_message)
 160
 161         self.assertEqual(delegate._callbacks, expected_callbacks)
 162         self.assertEqual(delegate.stop_message, termination_message)
 163
 164     def test_terminating_error(self):
 165         self._test_terminating_queue(KeyboardInterrupt(), "User terminated queue.")
 166         self._test_terminating_queue(TerminateQueue(), "TerminateQueue exception received.")
 167
 168     def test_now(self):
 169         """Make sure there are no typos in the QueueEngine.now() method."""
 170         engine = QueueEngine("test", None, None)
 171         self.assertIsInstance(engine._now(), datetime.datetime)
 172
 173     def test_sleep_message(self):
 174         engine = QueueEngine("test", None, None)
 175         engine._now = lambda: datetime.datetime(2010, 1, 1)
 176         expected_sleep_message = "MESSAGE Sleeping until 2010-01-01 00:02:00 (2 mins)."
 177         self.assertEqual(engine._sleep_message("MESSAGE"), expected_sleep_message)
 178
 179     def setUp(self):
 180         self.temp_dir = tempfile.mkdtemp(suffix="work_queue_test_logs")
 181
 182     def tearDown(self):
 183         shutil.rmtree(self.temp_dir)