cq_stats: only take into account attempts within current date range

infra/tools/cq_stats/test/cq_stats_test.py

 # Copyright 2015 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.
 
 import argparse
 import collections
 import copy
 import datetime
 import itertools
 import logging
@@ skipping 351 matching lines @@
       '99': 98.01,
       'max': 99.0,
       'mean': 49.5,
       'min': 0.0,
       'size': 100.0,
     }, stats)
 
     self.assertEqual(cq_stats.derive_list_stats([])['size'], 1)
 
   def get_mock_derive_patch_stats(self, supported=True):
-    def mock_derive_patch_stats(_, patch_id):
+    def mock_derive_patch_stats(_begin_date, _end_date, patch_id):

[Adrian Kuegel, 2015/05/26 14:40:47]

nit: I think this should be just begin_date and end_date without leading '_'.

[Paweł Hajdan Jr., 2015/05/27 09:19:56]

That triggers pylint warnings. I'm leaving the code as-is.

** Presubmit ERRORS **
Pylint (187 files under infra) (26.35s) failed
************* Module infra.tools.cq_stats.test.cq_stats_test
W:372,32: Unused argument 'begin_date' (unused-argument)
W:372,44: Unused argument 'end_date' (unused-argument)

       # The original function expects patch_id to be a 2-tuple.
       self.assertIsInstance(patch_id, tuple)
       self.assertEqual(len(patch_id), 2)
       # Note: these fields are required by derive_stats(). Make sure
       # they are present in the unit tests for derive_patch_stats().
       stats = {
           'attempts': 3,
           'false-rejections': 1,
           'rejections': 2,
           'committed': True,
           'patchset-duration-wallclock': 1234.56,
           'patchset-duration': 999.99,
           'failed-jobs-details': {'tester': 2},
           'supported': supported,
       }
       return patch_id, stats
     return mock_derive_patch_stats
 
   def test_derive_stats(self):
     # Unused args: pylint: disable=W0613
-    def mock_fetch_cq_logs_0(begin_date=None, end_date=None, filters=None):
+    def mock_fetch_cq_logs_0(start_date=None, end_date=None, filters=None):
       return []
     # Unused args: pylint: disable=W0613
-    def mock_fetch_cq_logs(begin_date=None, end_date=None, filters=None):
+    def mock_fetch_cq_logs(start_date=None, end_date=None, filters=None):
       return [
           {'fields': {'issue': 12345, 'patchset': 1},
            'timestamp': 1415150483.18568,
           },
       ]
 
     self.mock(cq_stats, 'derive_patch_stats', self.get_mock_derive_patch_stats(
         supported=True))
     # Test empty logs.
     self.mock(cq_stats, 'fetch_cq_logs', mock_fetch_cq_logs_0)
@@ skipping 72 matching lines @@
         attempt('Try jobs failed:\n test_dbg', reason='simple try job'),
         attempt('Try jobs failed:\n chromium_presubmit'),
         attempt('Exceeded time limit waiting for builds to trigger'),
         attempt('Some totally random unknown reason') + [
             {'fields': {'action': 'random garbage'},
              'timestamp': time_obj['time'] + 0.5}],
         attempt('', commit=True),
     ]
 
     # Dangerous default value, unused args: pylint: disable=W0102,W0613
-    def mock_fetch_cq_logs(begin_date=None, end_date=None, filters=[]):
+    def mock_fetch_cq_logs(start_date=None, end_date=None, filters=[]):
       entries = list(itertools.chain(*attempts))
       entries.reverse()
       return entries
 
     # Dangerous default value, unused args: pylint: disable=W0102,W0613
-    def mock_fetch_cq_logs_0(begin_date=None, end_date=None, filters=[]):
+    def mock_fetch_cq_logs_0(start_date=None, end_date=None, filters=[]):
       return []
 
     # Dangerous default value, unused args: pylint: disable=W0102,W0613
-    def mock_fetch_cq_logs_junk(begin_date=None, end_date=None, filters=[]):
+    def mock_fetch_cq_logs_junk(start_date=None, end_date=None, filters=[]):
       return [{'fields': {'action': 'cq_start'}, 'timestamp': 1415150662.3}]
 
     self.mock(cq_stats, 'fetch_cq_logs', mock_fetch_cq_logs)
 
     patch_id = ('pid', 5)
     pid, stats = cq_stats.derive_patch_stats(
-        datetime.datetime(2014, 10, 15), patch_id)
+        datetime.datetime(2014, 10, 15),
+        datetime.datetime(2014, 10, 15),
+        patch_id)
     self.assertEqual(patch_id, pid)
     # Check required fields in the result.
     mock_derive_patch_stats = self.get_mock_derive_patch_stats()
-    for k in mock_derive_patch_stats(None, patch_id)[1]:
+    for k in mock_derive_patch_stats(None, None, patch_id)[1]:
       self.assertIsNotNone(stats.get(k))
     # A few sanity checks.
     self.assertEqual(stats['attempts'], len(attempts))
     self.assertEqual(stats['committed'], True)
     self.assertGreater(stats['false-rejections'], 0)
 
     self.mock(cq_stats, 'fetch_cq_logs', mock_fetch_cq_logs_0)
     pid, stats = cq_stats.derive_patch_stats(
-        datetime.datetime(2014, 10, 15), patch_id)
+        datetime.datetime(2014, 10, 15),
+        datetime.datetime(2014, 10, 15),
+        patch_id)
     # Cover the case when there are actions, but no CQ attempts.
     self.mock(cq_stats, 'fetch_cq_logs', mock_fetch_cq_logs_junk)
     pid, stats = cq_stats.derive_patch_stats(
-        datetime.datetime(2014, 10, 15), patch_id)
+        datetime.datetime(2014, 10, 15),
+        datetime.datetime(2014, 10, 15),
+        patch_id)
 
 
   def test_derive_tree_stats(self):
     def makeDate(days=0, hours=0, minutes=0, seconds=0):
       start_date = datetime.datetime(2014, 10, 1, 15, 20, 12, 345)
       return start_date + datetime.timedelta(
           days=days, seconds=hours*3600+minutes*60+seconds)
 
     events =  [
         {'date': makeDate(-1),
@@ skipping 156 matching lines @@
     cq_stats.acquire_stats(Args(
         project='chromium', bots=[], use_logs=True, range='hour'))
 
   def test_main(self):
     self.mock(cq_stats, 'output', self.print_mock)
     self.mock(cq_stats, 'parse_args', lambda: Args(
         project='chromium', log_level=logging.CRITICAL, logs_black_list=None))
     self.mock(cq_stats, 'acquire_stats', lambda _: cq_stats.default_stats())
     cq_stats.main()
     return self.expectations