[Monorail] Deflake the unit tests for parsing date queries.

appengine/monorail/search/query2ast.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is govered by a BSD-style
 # license that can be found in the LICENSE file or at
 # https://developers.google.com/open-source/licenses/bsd
 
 """A set of functions that integrate the GAE search index with Monorail."""
 
 import collections
 import datetime
 import logging
@@ skipping 120 matching lines @@
     '-after': '>',
     '-before': '<',
 }
 
 BUILTIN_ISSUE_FIELDS = {
     f_name: tracker_pb2.FieldDef(field_name=f_name, field_type=f_type)
     for f_name, f_type in _ISSUE_FIELDS_LIST}
 
 
 def ParseUserQuery(
-    query, scope, builtin_fields, harmonized_config, warnings=None):
+    query, scope, builtin_fields, harmonized_config, warnings=None,
+    now=None):
   """Parse a user query and return a set of structure terms.
 
   Args:
     query: string with user's query.  E.g., 'Priority=High'.
     scope: string search terms that define the scope in which the
         query should be executed.  They are expressed in the same
         user query language.  E.g., adding the canned query.
     builtin_fields: dict {field_name: FieldDef(field_name, type)}
         mapping field names to FieldDef objects for built-in fields.
     harmonized_config: config for all the projects being searched.
         @@@ custom field name is not unique in cross project search.
          - custom_fields = {field_name: [fd, ...]}
          - query build needs to OR each possible interpretation
          - could be label in one project and field in another project.
         @@@ what about searching across all projects?
     warnings: optional list to accumulate warning messages.
+    now: optional timestamp for tests, otherwise time.time() is used.
 
   Returns:
     A QueryAST with conjunctions (usually just one), where each has a list of
     Condition PBs with op, fields, str_values and int_values.  E.g., the query
     [priority=high leak OR stars>100] over open issues would return
     QueryAST(
       Conjunction(Condition(EQ, [open_fd], [], [1]),
                   Condition(EQ, [label_fd], ['priority-high'], []),
                   Condition(TEXT_HAS, any_field_fd, ['leak'], [])),
       Conjunction(Condition(EQ, [open_fd], [], [1]),
@@ skipping 19 matching lines @@
   # Make a dictionary of all fields: built-in + custom in each project.
   combined_fields = collections.defaultdict(
       list, {field_name: [field_def]
              for field_name, field_def in builtin_fields.iteritems()})
   for fd in harmonized_config.field_defs:
     if fd.field_type != tracker_pb2.FieldTypes.ENUM_TYPE:
       # Only do non-enum fields because enums are stored as labels
       combined_fields[fd.field_name.lower()].append(fd)
 
   conjunctions = [
-      _ParseConjunction(sq, scope, combined_fields, warnings)
+      _ParseConjunction(sq, scope, combined_fields, warnings, now=now)
       for sq in subqueries]
   logging.info('search warnings: %r', warnings)
   return ast_pb2.QueryAST(conjunctions=conjunctions)
 
 
 def _HasParens(s):
   """Return True if there are parentheses in the given string."""
   # Monorail cannot handle parenthesized expressions, so we tell the
   # user that immediately.  Even inside a quoted string, the GAE search
   # engine will not handle parens in TEXT-type fields.
   return '(' in s or ')' in s
 
 
-def _ParseConjunction(subquery, scope, fields, warnings):
+def _ParseConjunction(subquery, scope, fields, warnings, now=None):
   """Parse part of a user query into a Conjunction PB."""
   logging.info('Parsing sub query: %r in scope %r', subquery, scope)
   scoped_query = ('%s %s' % (scope, subquery)).lower()
   cond_strs = _ExtractConds(scoped_query)
-  conds = [_ParseCond(cond_str, fields, warnings) for cond_str in cond_strs]
+  conds = [_ParseCond(cond_str, fields, warnings, now=now)
+           for cond_str in cond_strs]
   conds = [cond for cond in conds if cond]
   return ast_pb2.Conjunction(conds=conds)
 
 
-def _ParseCond(cond_str, fields, warnings):
+def _ParseCond(cond_str, fields, warnings, now=None):
   """Parse one user query condition string into a Condition PB."""
   op_match = OP_RE.match(cond_str)
   # Do not treat as key:value search terms if any of the special prefixes match.
   special_prefixes_match = any(
       cond_str.startswith(p) for p in fulltext_helpers.NON_OP_PREFIXES)
   if op_match and not special_prefixes_match:
     prefix = op_match.group('prefix')
     op = op_match.group('op')
     val = op_match.group('value')
     # Special case handling to continue to support old date query terms from
     # codesite. See monorail:151 for more details.
     if prefix.startswith(_DATE_FIELDS):
       for date_suffix in _DATE_FIELD_SUFFIX_TO_OP:
         if prefix.endswith(date_suffix):
           prefix = prefix.rstrip(date_suffix)
           op = _DATE_FIELD_SUFFIX_TO_OP[date_suffix]
-    return _ParseStructuredTerm(prefix, op, val, fields)
+    return _ParseStructuredTerm(prefix, op, val, fields, now=now)
 
   # Treat the cond as a full-text search term, which might be negated.
   if cond_str.startswith('-'):
     op = NOT_TEXT_HAS
     cond_str = cond_str[1:]
   else:
     op = TEXT_HAS
 
   # Construct a full-text Query object as a dry-run to validate that
   # the syntax is acceptable.
   try:
     _fts_query = search.Query(cond_str)
   except search.QueryError:
     warnings.append('Ignoring full-text term: %s' % cond_str)
     return None
 
   # Flag a potential user misunderstanding.
   if cond_str.lower() in ('and', 'or', 'not'):
     warnings.append(
         'The only supported boolean operator is OR (all capitals).')
 
   return ast_pb2.MakeCond(
       op, [BUILTIN_ISSUE_FIELDS[ast_pb2.ANY_FIELD]], [cond_str], [])
 
 
-def _ParseStructuredTerm(prefix, op_str, value, fields):
+def _ParseStructuredTerm(prefix, op_str, value, fields, now=None):
   """Parse one user structured query term into an internal representation.
 
   Args:
     prefix: The query operator, usually a field name.  E.g., summary. It can
       also be special operators like "is" to test boolean fields.
     op_str: the comparison operator.  Usually ":" or "=", but can be any OPS.
     value: the value to compare against, e.g., term to find in that field.
     fields: dict {name_lower: [FieldDef, ...]} for built-in and custom fields.
+    now: optional timestamp for tests, otherwise time.time() is used.
 
   Returns:
     A Condition PB.
   """
   unquoted_value = value.strip('"')
   # Quick-OR is a convenient way to write one condition that matches any one of
   # multiple values, like set membership.  E.g., [Priority=High,Critical].
   quick_or_vals = [v.strip() for v in unquoted_value.split(',')]
 
   if ((prefix == 'is' or prefix == '-is') and
@@ skipping 18 matching lines @@
       return ast_pb2.MakeCond(op, fields[unquoted_value], [], [])
     else:  # Look for any label with that prefix.
       return ast_pb2.MakeCond(op, fields['label'], [unquoted_value], [])
 
   if prefix in fields:  # search built-in and custom fields. E.g., summary.
     # Note: if first matching field is date-type, we assume they all are.
     # TODO(jrobbins): better handling for rare case where multiple projects
     # define the same custom field name, and one is a date and another is not.
     first_field = fields[prefix][0]
     if first_field.field_type == DATE:
-      date_value = _ParseDateValue(unquoted_value)
+      date_value = _ParseDateValue(unquoted_value, now=now)
       return ast_pb2.MakeCond(op, fields[prefix], [], [date_value])
     else:
       quick_or_ints = []
       for qov in quick_or_vals:
         try:
           quick_or_ints.append(int(qov))
         except ValueError:
           pass
       return ast_pb2.MakeCond(op, fields[prefix], quick_or_vals, quick_or_ints)
 
@@ skipping 44 matching lines @@
         # as fulltext search.  It is probably a tiny bit of source code.
         terms.append('"%s"' % word_label)
 
     # Case 3: Simple words.
     elif word:
       terms.append(word)
 
   return terms
 
 
-def _ParseDateValue(val):
+def _ParseDateValue(val, now=None):
   """Convert the user-entered date into timestamp."""
   # Support timestamp value such as opened>1437671476
   try:
     return int(val)
   except ValueError:
     pass
 
   # TODO(jrobbins): future: take timezones into account.
   # TODO(jrobbins): for now, explain to users that "today" is
   # actually now: the current time, not 12:01am in their timezone.
   # In fact, it is not very useful because everything in the system
   # happened before the current time.
   if val == 'today':
-    return _CalculatePastDate(0)
+    return _CalculatePastDate(0, now=now)
   elif val.startswith('today-'):
     try:
       days_ago = int(val.split('-')[1])
     except ValueError:
       raise InvalidQueryError('Could not parse date: ' + val)
-    return _CalculatePastDate(days_ago)
+    return _CalculatePastDate(days_ago, now=now)
 
   try:
     if '/' in val:
       year, month, day = [int(x) for x in val.split('/')]
     elif '-' in val:
       year, month, day = [int(x) for x in val.split('-')]
     else:
       raise InvalidQueryError('Could not parse date: ' + val)
   except ValueError:
     raise InvalidQueryError('Could not parse date: ' + val)
@@ skipping 24 matching lines @@
 
 
 class Error(Exception):
   """Base exception class for this package."""
   pass
 
 
 class InvalidQueryError(Error):
   """Error raised when an invalid query is requested."""
   pass