search_queries_test.py

# Copyright 2020 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License")
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import testing_config  # Must be imported before the module under test.

import datetime
from unittest import mock

from internals import core_enums
from internals.core_models import FeatureEntry, MilestoneSet, Stage
from internals.review_models import Gate, Vote
from internals import search
from internals import search_fulltext
from internals import search_queries


class SearchFeaturesTest(testing_config.CustomTestCase):

  def setUp(self):
    self.feature_1 = FeatureEntry(
        name='feature a', summary='sum',
        category=1, impl_status_chrome=3)
    self.feature_1.owner_emails = ['owner@example.com']
    self.feature_1.editor_emails = ['editor@example.com']
    self.feature_1.cc_emails = ['cc@example.com']
    self.feature_1.put()
    self.feature_1_id = self.feature_1.key.integer_id()
    search_fulltext.index_feature(self.feature_1)

    self.stage_1_ship = Stage(
      feature_id=self.feature_1_id,
      stage_type=core_enums.STAGE_BLINK_SHIPPING,
      milestones=MilestoneSet(desktop_first=99, android_first=100),
    )
    self.stage_1_ship.put()

    self.feature_2 = FeatureEntry(
      name='feature b',
      summary='summary of editor stuff',
      owner_emails=['owner@example.com'],
      category=1,
      impl_status_chrome=3,
      accurate_as_of=datetime.datetime(2023, 6, 1),
    )
    self.feature_2.put()
    search_fulltext.index_feature(self.feature_1)
    self.feature_2_id = self.feature_2.key.integer_id()
    self.stage_2_ot = Stage(
      feature_id=self.feature_2_id,
      stage_type=core_enums.STAGE_BLINK_ORIGIN_TRIAL,
      milestones=MilestoneSet(desktop_first=89, desktop_last=95, webview_first=100),
    )
    self.stage_2_ot.put()

    self.feature_3 = FeatureEntry(
      name='feature c',
      summary='sum',
      owner_emails=['random@example.com'],
      category=1,
      impl_status_chrome=4,
      accurate_as_of=datetime.datetime(2024, 6, 1),
    )
    self.feature_3.put()
    self.feature_3_id = self.feature_3.key.integer_id()

    self.gate_1 = Gate(
        feature_id=self.feature_1_id, stage_id=1,
        gate_type=core_enums.GATE_API_PROTOTYPE,
        state=Vote.APPROVED,
        requested_on=datetime.datetime(2022, 7, 1))
    self.gate_1.put()
    self.gate_1_id = self.gate_1.key.integer_id()

    self.vote_1_1 = Vote(
        feature_id=self.feature_1_id, gate_type=core_enums.GATE_API_PROTOTYPE,
        gate_id=self.gate_1_id,
        state=Vote.REVIEW_REQUESTED,
        set_on=datetime.datetime(2022, 7, 1),
        set_by='feature_owner@example.com')
    self.vote_1_1.put()

    self.vote_1_2 = Vote(
        feature_id=self.feature_1_id, gate_type=core_enums.GATE_API_PROTOTYPE,
        gate_id=self.gate_1_id,
        state=Vote.APPROVED,
        set_on=datetime.datetime(2022, 7, 2),
        set_by='reviewer@example.com')
    self.vote_1_2.put()

    self.gate_2 = Gate(
        feature_id=self.feature_2_id, stage_id=1,
        gate_type=core_enums.GATE_API_SHIP,
        state=Vote.REVIEW_REQUESTED,
        requested_on=datetime.datetime(2022, 8, 1))
    self.gate_2.put()
    self.gate_2_id = self.gate_2.key.integer_id()

    self.vote_2_1 = Vote(
        feature_id=self.feature_2_id, gate_type=core_enums.GATE_API_SHIP,
        gate_id=self.gate_2_id,
        state=Vote.REVIEW_REQUESTED,
        set_on=datetime.datetime(2022, 8, 1),
        set_by='feature_owner@example.com')
    self.vote_2_1.put()

    self.vote_2_2 = Vote(
        feature_id=self.feature_2_id, gate_type=core_enums.GATE_API_SHIP,
        gate_id=self.gate_2_id,
        state=Vote.APPROVED,
        set_on=datetime.datetime(2022, 8, 2),
        set_by='reviewer@example.com')
    self.vote_2_2.put()

  def tearDown(self):
    for kind in [
        FeatureEntry, search_fulltext.FeatureWords, Stage, Gate, Vote]:
      for entry in kind.query():
        entry.key.delete()

  def test_single_field_query_async__normal(self):
    """We get a promise to run the DB query, which produces results."""
    actual_promise = search_queries.single_field_query_async(
        'owner', '=', ['owner@example.com'])
    actual = actual_promise.get_result()
    self.assertCountEqual(
        [self.feature_1_id, self.feature_2_id],
        [key.integer_id() for key in actual])

    actual_promise = search_queries.single_field_query_async(
        'unlisted', '=', [True])
    actual = actual_promise.get_result()
    self.assertCountEqual([], actual)

    actual_promise = search_queries.single_field_query_async(
        'deleted', '=', [True])
    actual = actual_promise.get_result()
    self.assertCountEqual([], actual)

  def test_single_field_query_async__multiple_vals(self):
    """We get a promise to run the DB query with multiple values."""
    actual_promise = search_queries.single_field_query_async(
        'owner', '=', ['owner@example.com', 'random@example.com'])
    actual = actual_promise.get_result()
    self.assertCountEqual(
        [self.feature_1_id, self.feature_2_id, self.feature_3_id],
        [key.integer_id() for key in actual])

  def test_single_field_query_async__inequality_nulls_first(self):
    """accurate_as_of treats None as before any comparison value."""
    actual_promise = search_queries.single_field_query_async(
      'accurate_as_of', '<', [datetime.datetime(2024, 1, 1)]
    )
    actual = actual_promise.get_result()
    self.assertCountEqual(
      [self.feature_1_id, self.feature_2_id], [key.integer_id() for key in actual]
    )

    actual_promise = search_queries.single_field_query_async(
      'accurate_as_of', '>', [datetime.datetime(2024, 1, 1)]
    )
    actual = actual_promise.get_result()
    self.assertCountEqual([self.feature_3_id], [key.integer_id() for key in actual])

  def test_single_field_query_async__any_start_milestone(self):
    actual = search_queries.single_field_query_async(
      'any_start_milestone', '=', [100]
    ).get_result()
    self.assertEqual(
      set([self.feature_1_id, self.feature_2_id]),
      set(proj.feature_id for proj in actual),
      'Finds across multiple milestones.',
    )

    actual = search_queries.single_field_query_async(
      'any_start_milestone', '=', [95]
    ).get_result()
    self.assertEqual(
      set(), set(proj.feature_id for proj in actual), 'Does not find "last" milestones.'
    )

    actual = search_queries.single_field_query_async(
      'any_start_milestone', '=', [search_queries.Interval(97, 99)]
    ).get_result()
    self.assertCountEqual(
      set([self.feature_1_id]),
      set(proj.feature_id for proj in actual),
      'Intervals are constrained to a single milestone.',
    )

  def check_wrong_type(self, field_name, bad_values):
    with self.assertRaises(ValueError) as cm:
      search_queries.single_field_query_async(
          field_name, '=', bad_values)
    self.assertEqual(
        cm.exception.args[0], 'Query value does not match field type')

  def test_single_field_query_async__wrong_types(self):
    """We reject requests with values that parse to the wrong type."""
    # Feature entry fields
    self.check_wrong_type('owner', [True])
    self.check_wrong_type('owner', [123])
    self.check_wrong_type('deleted', ['not a boolean'])
    self.check_wrong_type('shipping_year', ['not an integer'])
    self.check_wrong_type('star_count', ['not an integer'])
    self.check_wrong_type('created.when', ['not a date'])
    self.check_wrong_type('owner', ['ok@example.com', True])

    # Stage fields
    self.check_wrong_type('browsers.chrome.android', ['not an integer'])
    self.check_wrong_type('finch_url', [123])
    self.check_wrong_type('finch_url', [True])

  def test_single_field_query_async__normal_stage_field(self):
    """We can find a FeatureEntry based on values in an associated Stage."""
    actual_promise = search_queries.single_field_query_async(
        'browsers.chrome.desktop', '=', [99])
    actual = actual_promise.get_result()
    self.assertCountEqual(
        [self.feature_1_id],
        [projection.feature_id for projection in actual])

  def test_single_field_query_async__other_stage_field(self):
    """We only consider the appropriate Stage."""
    actual_promise = search_queries.single_field_query_async(
        'browsers.chrome.ot.desktop.start', '=', [99])
    actual = actual_promise.get_result()
    self.assertCountEqual([], actual)

  def test_single_field_query_async__zero_results(self):
    """When there are no matching results, we get back a promise for []."""
    actual_promise = search_queries.single_field_query_async(
        'owner', '=', ['nope'])
    actual = actual_promise.get_result()
    self.assertCountEqual([], actual)

  def test_single_field_query_async__fulltext_in_field(self):
    """We can search for words within a field."""
    actual = search_queries.single_field_query_async(
        'editor', ':', ['editor'])
    self.assertCountEqual([self.feature_1_id], actual)

    actual = search_queries.single_field_query_async(
        'editor', ':', ['wrongword'])
    self.assertCountEqual([], actual)

    actual = search_queries.single_field_query_async(
        'owner', ':', ['editor'])
    self.assertCountEqual([], actual)

  @mock.patch('logging.warning')
  def test_single_field_query_async__bad_field(self, mock_warn):
    """An unknown field imediately gives zero results."""
    actual = search_queries.single_field_query_async('zodiac', '=', ['leo'])
    self.assertCountEqual([], actual)

  def test_handle_me_query_async__owner_anon(self):
    """We can return a list of features owned by the user."""
    testing_config.sign_in('visitor@example.com', 111)
    future = search_queries.handle_me_query_async('owner')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(actual, [])

  def test_handle_me_query__owner_some(self):
    """We can return a list of features owned by the user."""
    testing_config.sign_in('owner@example.com', 111)
    future = search_queries.handle_me_query_async('owner')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_1_id, self.feature_2_id], actual)

  def test_handle_me_query__editor_none(self):
    """We can return a list of features the user can edit."""
    testing_config.sign_in('visitor@example.com', 111)
    future = search_queries.handle_me_query_async('editor')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([], actual)

  def test_handle_me_query__editor_some(self):
    """We can return a list of features the user can edit."""
    testing_config.sign_in('editor@example.com', 111)
    future = search_queries.handle_me_query_async('editor')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([self.feature_1_id], actual)

  def test_handle_me_query__cc_none(self):
    """We can return a list of features the user is CC'd on."""
    testing_config.sign_in('visitor@example.com', 111)
    future = search_queries.handle_me_query_async('cc')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(actual, [])

  def test_handle_me_query__cc_some(self):
    """We can return a list of features the user is CC'd on."""
    testing_config.sign_in('cc@example.com', 111)
    future = search_queries.handle_me_query_async('cc')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([self.feature_1_id], actual)

  def test_handle_can_edit_me_query_async__anon(self):
    """Anon cannot edit any features."""
    testing_config.sign_out()
    future = search_queries.handle_can_edit_me_query_async()
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([], actual)

  def test_handle_can_edit_me_query_async__visitor(self):
    """Visitor cannot edit any features."""
    testing_config.sign_in('visitor@example.com', 111)
    future = search_queries.handle_can_edit_me_query_async()
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([], actual)

  def test_handle_can_edit_me_query_async__owner(self):
    """A feature owner can edit those features."""
    testing_config.sign_in('owner@example.com', 111)
    future = search_queries.handle_can_edit_me_query_async()
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_1_id, self.feature_2_id], actual)

  def test_handle_can_edit_me_query_async__editor(self):
    """A feature editor can edit those features."""
    testing_config.sign_in('editor@example.com', 111)
    future = search_queries.handle_can_edit_me_query_async()
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual([self.feature_1_id], actual)

  def test_total_order_query_async__field_asc(self):
    """We can get keys used to sort features in ascending order."""
    future = search_queries.total_order_query_async('name')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_1_id, self.feature_2_id, self.feature_3_id], actual)

  def test_total_order_query_async__field_desc(self):
    """We can get keys used to sort features in descending order."""
    future = search_queries.total_order_query_async('-name')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_3_id, self.feature_2_id, self.feature_1_id], actual)

  def test_total_order_query_async__requested_on(self):
    """We can get feature IDs sorted by gate review requests."""
    future = search_queries.total_order_query_async('gate.requested_on')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_2_id],
        actual)

  def test_total_order_query_async__reviewed_on(self):
    """We can get feature IDs sorted by gate resolution times."""
    future = search_queries.total_order_query_async('gate.reviewed_on')
    actual = search._resolve_promise_to_id_list(future)
    self.assertEqual(
        [self.feature_1_id, self.feature_2_id],
        actual)

  def test_stage_fields_have_join_conditions(self):
    """Every STAGE_QUERIABLE_FIELDS has a STAGE_TYPES_BY_QUERY_FIELD entry."""
    self.assertCountEqual(
        search_queries.STAGE_QUERIABLE_FIELDS.keys(),
        search_queries.STAGE_TYPES_BY_QUERY_FIELD.keys())

  def test_negate_operator(self):
    """We can get correct negated operators"""
    actual = search_queries.negate_operator('=')
    self.assertEqual('!=', actual)

    actual = search_queries.negate_operator('!=')
    self.assertEqual('=', actual)

    actual = search_queries.negate_operator('<')
    self.assertEqual('>=', actual)

    actual = search_queries.negate_operator('<=')
    self.assertEqual('>', actual)

    actual = search_queries.negate_operator('>')
    self.assertEqual('<=', actual)

    actual = search_queries.negate_operator('>=')
    self.assertEqual('<', actual)