Merge lp:~al-maisan/launchpad/spurious-tests-525329 into lp:launchpad/db-devel

[Muharem Hrnjadovic]

[Muharem Hrnjadovic (al-maisan)]

Hello,

quite a few tests that predict times or durations failed in spurious
fashion in the last few days.

The branch at hand introduces a BuildQueue._now() method that is used by the
BuildQueue code under test while enabling the unit tests to "monkey-patch"
that method and have it return a constant time in order to facilitate the
testing process.

This is based on an idea of Julian's.

Tests to run:

    bin/test -vv -t test_buildqueue

No "make lint" errors or warnings.

[Graham Binns (gmb)]

review: Approve (code)

=== modified file 'lib/lp/soyuz/model/buildqueue.py'
--- lib/lp/soyuz/model/buildqueue.py	2010-02-22 08:30:06 +0000
+++ lib/lp/soyuz/model/buildqueue.py	2010-03-01 16:30:47 +0000
@@ -223,16 +223,17 @@
 
         head_job_processor, head_job_virtualized = head_job_platform
 
+        now = self._now()
         delay_query = """
             SELECT MIN(
               CASE WHEN
                 EXTRACT(EPOCH FROM
                   (BuildQueue.estimated_duration -
-                   (((now() AT TIME ZONE 'UTC') - Job.date_started))))  >= 0
+                   (((%s AT TIME ZONE 'UTC') - Job.date_started))))  >= 0
               THEN
                 EXTRACT(EPOCH FROM
                   (BuildQueue.estimated_duration -
-                   (((now() AT TIME ZONE 'UTC') - Job.date_started))))
+                   (((%s AT TIME ZONE 'UTC') - Job.date_started))))
               ELSE
                 -- Assume that jobs that have overdrawn their estimated
                 -- duration time budget will complete within 2 minutes.
@@ -253,7 +254,7 @@
                 AND Job.status = %s
                 AND Builder.virtualized = %s
             """ % sqlvalues(
-                JobStatus.RUNNING,
+                now, now, JobStatus.RUNNING,
                 normalize_virtualization(head_job_virtualized))
 
         if head_job_processor is not None:
@@ -460,10 +461,15 @@
 
         # A job will not get dispatched in less than 5 seconds no matter what.
         start_time = max(5, min_wait_time + sum_of_delays)
-        result = datetime.utcnow() + timedelta(seconds=start_time)
+        result = self._now() + timedelta(seconds=start_time)
 
         return result
 
+    @staticmethod
+    def _now():
+        """Provide utcnow() while allowing test code to monkey-patch this."""
+        return datetime.utcnow()
+
 
 class BuildQueueSet(object):
     """Utility to deal with BuildQueue content class."""

=== modified file 'lib/lp/soyuz/tests/test_buildqueue.py'
--- lib/lp/soyuz/tests/test_buildqueue.py	2010-02-25 16:34:13 +0000
+++ lib/lp/soyuz/tests/test_buildqueue.py	2010-03-01 16:30:47 +0000
@@ -96,8 +96,12 @@
             queue_entry.lastscore)
 
 
-def check_mintime_to_builder(test, bq, min_time):
+def check_mintime_to_builder(
+    test, bq, min_time, time_stamp=datetime.utcnow()):
     """Test the estimated time until a builder becomes available."""
+    # Monkey-patch BuildQueueSet._now() so it returns a constant time stamp
+    # that's not too far in the future. This avoids spurious test failures.
+    monkey_patch_the_now_property(bq)
     delay = bq._estimateTimeToNextBuilder()
     test.assertTrue(
         delay <= min_time,
@@ -131,8 +135,24 @@
     return builder_data[(getattr(job.processor, 'id', None), job.virtualized)]
 
 
+def monkey_patch_the_now_property(buildqueue):
+    """Patch BuildQueue._now() so it returns a constant time stamp.
+
+    This avoids spurious test failures.
+    """
+    # Use the date/time the job started if available.
+    time_stamp = buildqueue.job.date_started
+    if not time_stamp:
+        time_stamp = datetime.utcnow()
+    buildqueue._now = lambda: time_stamp
+    return time_stamp
+
+
 def check_estimate(test, job, delay_in_seconds):
     """Does the dispatch time estimate match the expectation?"""
+    # Monkey-patch BuildQueueSet._now() so it returns a constant time stamp.
+    # This avoids spurious test failures.
+    time_stamp = monkey_patch_the_now_property(job)
     estimate = job.getEstimatedJobStartTime()
     if delay_in_seconds is None:
         test.assertEquals(
@@ -140,7 +160,7 @@
             "An estimate should not be possible at present but one was "
             "returned (%s) nevertheless." % estimate)
     else:
-        estimate -= datetime.utcnow()
+        estimate -= time_stamp
         test.assertTrue(
             estimate.seconds <= delay_in_seconds,
             "The estimated delay deviates from the expected one (%s > %s)" %
@@ -495,9 +515,7 @@
 class TestMinTimeToNextBuilder(SingleArchBuildsBase):
     """Test estimated time-to-builder with builds targetting a single
     processor."""
-    # XXX Michael Nelson 20100223 bug=525329
-    # This is still failing spuriously.
-    def disabled_test_min_time_to_next_builder(self):
+    def test_min_time_to_next_builder(self):
         """When is the next builder capable of running the job at the head of
         the queue becoming available?"""
         # Test the estimation of the minimum time until a builder becomes
@@ -684,9 +702,7 @@
 
 class TestMinTimeToNextBuilderMulti(MultiArchBuildsBase):
     """Test estimated time-to-builder with builds and multiple processors."""
-    # XXX Michael Nelson 20100223 bug=525329
-    # This is still failing spuriously.
-    def disabled_test_min_time_to_next_builder(self):
+    def test_min_time_to_next_builder(self):
         """When is the next builder capable of running the job at the head of
         the queue becoming available?"""
         # One of four builders for the 'apg' build is immediately available.